convez.ai
MCP ServerIntegração & APIsAvançado
kagura-ai

Kagura Memory Cloud

kagura-ai/memory-cloud

Memória adaptativa que aprende: RAG inteligente com grafo neural para agentes

Ver no GitHub
BomPluginScore · de 0 a 100

Servidor MCP que implementa memória adaptativa para agentes e times de IA, indo além de RAG tradicional. Combina busca híbrida (semântica + BM25), grafo neural que aprende com cada busca, e primitivos para agentes autônomos. Oferece 45 ferramentas MCP e funciona com Claude, ChatGPT, Gemini e qualquer cliente compatível.

Instalação

$npx convez-ai kagura-ai/memory-cloud

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
14
Forks
11
Acompanhando
0
Saúde
100%
Último commit
há 1 dia
Versão
v0.170.0
Issues abertas
20
Contribuidores
4

Casos de uso

  • Bases de conhecimento de times que evoluem com o uso
  • Agentes autônomos com memória persistente e descoberta de relacionamentos
  • Sistemas de busca inteligente em documentos corporativos
  • Manutenção de contexto entre conversas em aplicações multi-agente

Veredito

Solução robusta e diferenciada que implementa o padrão LLM Knowledge Base em escala organizacional. Ideal para equipes que precisam de memória composta e discovery inteligente, mas exige stack técnico estabelecido (PostgreSQL, Qdrant, MCP).

README

A tradução para o português deste README ainda está na fila.

Why Kagura Memory Cloud?

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:

ApproachStorageCompoundingScale
Vector DB / RAGEmbedded chunksNone — retrieve-onlyAny
Karpathy's LLM WikiMarkdown filesLLM rewrites pagesPersonal (~100 pages)
Kagura Memory CloudPostgreSQL + Qdrant + Neural graphHebbian + Sleep MaintenanceTeam / org
FeatureDescription
Adaptive MemoryEvery search automatically strengthens connections between related memories. The more you use it, the better explore() discovers hidden relationships.
Hybrid SearchSemantic (OpenAI/Ollama) + BM25 keyword — 96% top-1 accuracy
AI RerankingOllama (local, free), Voyage AI, or Cohere — cross-encoder reranking for precision
Neural Memory GraphHebbian learning builds a knowledge graph in the background. explore() traverses it for serendipitous discovery.
Agent Memory SubstrateBeyond a knowledge store: delivery modes (pinned / time-triggered), a server-stamped trust boundary, an agent state lane, and a retrieval-feedback signal — the primitives an autonomous agent loop needs.
45 MCP ToolsMemory, Agent Substrate, Neural edges, Contexts, Tags, Files (R2), Analyses (broadlistening), Resources, Sleep Maintenance, Usage, API-Key Bindings
Multi-ProviderOpenAI or Ollama (local, private, zero cost) for embeddings
Team ReadyWorkspaces, RBAC, context isolation, shared memory
Web UINext.js dashboard — contexts, search settings, member management
5-Minute Setup./setup.sh and you're done

Architecture

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)

LLM Knowledge Base — 5-Layer Implementation

Karpathy's LLM Wiki pattern describes a 5-layer "living knowledge base" — beyond traditional RAG. Kagura implements all 5 layers at team scale:

LayerKagura ImplementationDifference from Karpathy's pattern
IngestREST /api/v1/memory, MCP remember, R2 file storage, resource tokens+ binary blobs, + multi-tenant
CompileMCP-as-compile-API — chat agent compiles via structured tool calls (remember(summary, content, type, tags)) + Sleep Maintenance for batch consolidationContinuous micro-compile (not batch wiki rewrite) — schema-enforced output
IndexTriple index: BM25 (keyword) + Qdrant (semantic) + Hebbian graph (relational) — all auto-maintainedNo manual index.md upkeep
QueryHybrid Search + AI Reranker + explore graph traversalBeyond markdown grep — supports semantic + relational queries
EnhanceHebbian learning — every recall() strengthens edges between co-retrieved memories. Sleep Maintenance consolidates periodically.Background graph evolution (zero LLM cost) vs LLM-driven page rewrites

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.

Adaptive Memory: Two Search Paths

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.
  • Hebbian learning — Every 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

Quick Start

System Requirements

MinimumRecommended
CPU2 cores4+ cores
RAM4 GB8+ GB
Disk10 GB free20+ GB free

Prerequisites

  • Docker & Docker Compose
  • Python 3.11+
  • Node.js 20+
  • OpenAI API key (for embeddings) — or Ollama for local embeddings
  • OAuth2 credentials (optional — password + MFA login available without OAuth)

Setup

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):

SettingRequiredDescription
API_KEY_SECRETYesSecret for API key encryption (auto-generated)
JWT_SECRETYesSecret for JWT tokens (auto-generated)
OPENAI_API_KEYYes*OpenAI API key for embeddings
OLLAMA_BASE_URLNoOllama URL (default: http://localhost:11434)
EMBEDDING_PROVIDERNoopenai (default) or ollama
GOOGLE_CLIENT_ID/SECRETNoGoogle OAuth2 login (optional — password login available)
GITHUB_CLIENT_ID/SECRETNoGitHub OAuth2 login (optional)

* Either OPENAI_API_KEY or a running Ollama instance is required for memory features.

Admin CLI

CommandPurpose
python3 -m src.cli.setup_envGenerate secrets + configure .env.local (run before Docker)
python3 -m src.cli.create_adminCreate admin + workspace + API key + .mcp.json + embedding setup
python3 -m src.cli.reset_passwordReset password and/or MFA
python3 -m src.cli.delete_adminDelete admin (for re-creation)

Run from backend/ directory. Docker API container must be running.

  • WSL (Windows): Install Docker Desktop for Windows and enable WSL integration
  • macOS: Install Docker Desktop for Mac. brew install python@3.11 node
  • Linux (Ubuntu/Debian): sudo apt install docker.io docker-compose-v2 python3.11 nodejs npm
  • GCP (Production): Set production values in .env.local (DATABASE_URL, QDRANT_URL, ENVIRONMENT=production, CORS_ORIGINS)
  • Frontend env vars: Copy frontend/.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 metadata
    • NEXT_PUBLIC_PLAN_FREE_DISPLAY_NAME / BASIC / PRO — plan display name customization (default: S/M/L)

MCP Client Setup

Claude Code (Recommended)

Claude Code + Kagura Memory Cloud gives your AI assistant persistent, searchable, team-shareable memory that works across sessions, machines, and projects.

Why not just use Claude Code's built-in memory?

Claude Code MemoryKagura Memory Cloud
StorageLocal files (~/.claude/)Cloud (PostgreSQL + Qdrant)
SearchFile name onlyHybrid Search (semantic + full-text)
SharingSingle machineTeam workspace with RBAC
StructureFlat markdown3-layer architecture + Neural Memory graph
Cross-projectPer-project onlyAny project via MCP

Setup (3 steps):

  1. Start services and open http://localhost:3000/workspace/integrations/api-keys to create an API key
  2. Copy .mcp.json.example to .mcp.json and fill in your workspace ID and API key:
cp .mcp.json.example .mcp.json
# Edit .mcp.json — set workspace_id (from URL bar) and API key
  1. Restart Claude Code and verify:
You: "List my memory contexts"
→ AI calls list_contexts()

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.json is in .gitignore — never commit it (contains API keys). Place in project root for per-project config, or ~/.claude/.mcp.json for global access.

Kagura Memory Cloud includes a hook that automatically syncs Claude Code's local memory files to the cloud whenever they're updated. This means your local ~/.claude/ memories are also searchable via Hybrid Search and shared with your team.

Add these environment variables to .env.local:

KAGURA_MCP_URL=http://localhost:8080/mcp/w/{workspace_id}
KAGURA_MCP_TOKEN=kagura_{your_api_key}
KAGURA_CONTEXT_ID={context_id}  # optional — auto-detected from project name if omitted

The sync hook is pre-configured in .claude/settings.json and runs automatically on every memory file write.

This repo's .claude/ directory is a ready-to-use template for integrating Kagura Memory Cloud into any project. Copy what you need:

Slash commands — drop into your project's .claude/commands/:

/recall <query>   → Search past knowledge via MCP
/remember <text>  → Save decisions, patterns, learnings via MCP
/guide            → Show setup and usage guide

Hooks (.claude/settings.json) — auto-configured safety guards:

Auto-format    → ruff (Python) / prettier (TypeScript) on every save
Secret detect  → Blocks hardcoded API keys or passwords
SQL injection  → Blocks f-string SQL (enforces parameterized queries)
Memory sync    → Auto-syncs Claude Code memory files to Kagura Cloud

Agents (.claude/agents/) — specialized sub-agents:

code-reviewer  → Read-only code review against project standards
test-runner    → Run tests, diagnose failures, auto-fix

Rules (.claude/rules/) — auto-loaded project conventions:

backend.md     → FastAPI/Python patterns, async, testing
frontend.md    → Next.js/TypeScript, Tailwind, SWR
security.md    → Auth, RBAC, SQL safety, CORS

All of these are designed to work together with Kagura Memory Cloud MCP tools. Adapt them for your own project by editing the prompts and context IDs.

The kagura-memory plugin adds session management and memory workflow skills to Claude Code. Install it once and use it across all your projects.

Install:

# From marketplace
/plugin marketplace add kagura-ai/memory-cloud
/plugin install kagura-memory@kagura-memory-cloud

Available skills:

SkillDescription
/kagura-memory:session-startRestore previous session context on start
/kagura-memory:session-summarySave session knowledge before ending
/kagura-memory:recallSearch past knowledge
/kagura-memory:rememberSave new knowledge
/kagura-memory:guideUsage guide, connection status, and setup help
/kagura-memory:smoke-testVerify all MCP tools work

Recommended workflow:

/kagura-memory:session-start       # ← Start here: restore context from last session
  ... work normally ...
/kagura-memory:recall              # Search past decisions, patterns, fixes
/kagura-memory:remember            # Save important learnings as you go
  ... finish work ...
/kagura-memory:session-summary     # ← End here: save session knowledge for next time

Skills wrap the raw MCP tools (recall, remember, etc.) with workflow logic — context selection, git state analysis, and structured prompts. Use skills for session management and guided workflows; use MCP tools directly for fine-grained operations.

Run /kagura-memory:guide for setup help and an optional SessionStart hook you can add to your project.

Prerequisite: MCP connection must be configured (.mcp.json with API key). Run /kagura-memory:guide in your project to set it up.

WSL2 + Claude Code (NAT networking note)

If you run Claude Code inside WSL2 and use the OAuth flow (not the API-key setup above), the browser callback can fail silently: WSL2's default nat mode isolates localhost between Windows and WSL, so the Windows browser's redirect to localhost:<port> never reaches Claude Code's listener inside WSL. This is a WSL networking issue, not a Kagura server bug — the resolved server-side cousin was #689 / PR #692.

Quick fixes:

  • Enable mirrored networking — set networkingMode=mirrored in C:\Users\<YourName>\.wslconfig, then wsl --shutdown (requires WSL 2.0.0+ on Windows 11 22H2+).
  • Use API key (Bearer) auth — the .mcp.json setup above skips the OAuth callback entirely.
  • Use the device flow (#635 / PR #636, RFC 8628) if your client supports it.

See Troubleshooting → WSL2 + Claude Code for the full symptom → diagnosis → fix walkthrough.

Claude Desktop / Claude Chat (Web)

Claude Desktop: Same .mcp.json format as Claude Code — place in your project root or ~/.claude/.mcp.json.

Claude Chat (claude.ai): Add as a remote MCP server in Settings > Integrations:

  1. Click "Add Integration" → "Custom MCP Server"
  2. Enter the MCP endpoint URL: https://your-domain.com/mcp/w/{workspace_id}
  3. Add the Authorization: Bearer kagura_{your_api_key} header

Claude Chat requires a publicly accessible URL (not localhost). Use a production deployment or tunnel (e.g., ngrok, Cloudflare Tunnel).

ChatGPT Desktop

ChatGPT desktop app supports MCP servers. Add via Settings > MCP Servers:

  1. Server URL: https://your-domain.com/mcp/w/{workspace_id}
  2. Authentication: Bearer token kagura_{your_api_key}

Like Claude Chat, ChatGPT requires a public URL. For local development, use a tunnel or the REST API directly.

Gemini CLI

Add to .gemini/settings.json (project root or ~/.gemini/settings.json):

{
  "mcpServers": {
    "kagura-memory": {
      "url": "http://localhost:8080/mcp/w/{workspace_id}",
      "headers": {
        "Authorization": "Bearer kagura_{your_api_key}"
      }
    }
  }
}

Other MCP Clients / REST API

Any MCP-compatible client can connect via Streamable HTTP. For clients without MCP support, use the REST API directly:

# Search memories
curl -X POST -H "Authorization: Bearer kagura_{your_key}" \
  -H "Content-Type: application/json" \
  -d '{"query": "your search", "context_id": "..."}' \
  http://localhost:8080/api/v1/memories/search

MCP Tools

45 tools across 11 categories. Workspace roles: Owner > Admin > Member > Viewer (read-only). Context roles: Owner > Editor > Viewer. Private contexts are visible only to the creator. Members may be restricted to specific contexts via allowlist.

Memory (6)

ToolDescriptionRequired Role
rememberStore a new memory (summary + content + type; optional delivery_mode)Member+
recallSearch memories with Hybrid Search (supports trust_tier filter)Viewer+
referenceGet full 3-layer details of a memoryViewer+
update_memoryUpdate an existing memory in-place or upsert by external IDMember+
forgetSoft-delete a memory (30-day retention)Member+
exploreDiscover related memories via Neural Memory graphViewer+

Agent Substrate (5)

The primitives an autonomous agent loop needs beyond a knowledge store — see Concepts › Agent Memory Substrate.

ToolDescriptionRequired Role
load_pinnedDeterministically load always-load memories (delivery_mode="always") — Goal / Guardrail / policyViewer+
recall_upcomingList upcoming Time Memories (type="time", delivery_mode="on_trigger")Viewer+
set_stateUpsert agent scratch state (key→value, optional TTL; excluded from recall)Editor+
get_stateRead one state key, or list all live state for a contextViewer+
feedbackRecord whether a recalled memory was helpful (append-only signal)Viewer+

Neural Edges (4)

ToolDescriptionRequired Role
list_edgesList edges connected to a memoryViewer+
create_edgeCreate an edge between two memoriesMember+
update_edgeUpdate edge weight or typeMember+
delete_edgeDelete an edge between two memoriesMember+

Contexts (7)

ToolDescriptionRequired Role
get_context_infoGet context metadata and guidelinesViewer+
list_contextsList available contexts in workspaceViewer+
create_contextCreate a new contextOwner/Admin
update_contextUpdate context settings (summary, usage guide, resource_id, is_public)Editor+
delete_contextDelete a context and all its memoriesOwner/Admin
merge_contextsMerge memories from source context into target contextOwner/Admin
update_search_configTune hybrid search weights and reranker settings per contextEditor+

Tags (1)

ToolDescriptionRequired Role
list_tagsList tag vocabulary in a context (call before remember/recall to align tagging)Viewer+

Files / R2 Attachments (5)

ToolDescriptionRequired Role
init_file_uploadReserve quota + return presigned PUT URL (R2, ≤100 MiB)Member+
complete_file_uploadFinalize upload after R2 PUT, verify sha256, mark as uploadedMember+
list_filesList uploaded, non-deleted files in the workspace (newest first)Viewer+
get_file_download_urlIssue presigned GET URL for a fileViewer+
delete_fileSoft-delete a file objectMember+

Analyses — Broadlistening (5)

Cluster memories into themes (kouchou-ai-style UMAP + KMeans + LLM labeling) for large-scale qualitative analysis.

ToolDescriptionRequired Role
analyze_contextStart an analysis run (or preview cost with dry_run=true)Owner + Pro plan + BYOK + quota
list_analysesList past analysis runs for a contextOwner
get_analysisGet a completed analysis (clusters, labels, stats)Owner
get_active_analysisGet the in-flight analysis for a context (if any)Owner
get_clusterDrill into a single cluster's member memoriesOwner

Resources — External Data Ingestion (6)

ToolDescriptionRequired Role
setup_resourceCreate public context + issue resource tokenOwner/Admin + Pro plan
setup_connectorProvision an ai-worker chat connector (resource + connector row + token)Owner/Admin + connector seats
list_resource_tokensList active resource tokens for your workspaceOwner/Admin
ingest_eventsBatch upsert/delete events into a resource (max 100 events; session-auth MCP variant)Member+
get_resource_impactResource stats (tokens, memories, schema version)Viewer+
get_resource_schemaField definitions for a resourceViewer+

Sleep Maintenance (3)

Background consolidation of memories (decay, edge pruning, theme summarization).

ToolDescriptionRequired Role
get_sleep_historyList past sleep runsViewer+
get_sleep_reportDetailed sleep report with all actionsViewer+
rollback_sleep_runRollback all actions from a completed sleep runMember+ (report owner only)

Usage (1)

ToolDescriptionRequired Role
get_usageGet current workspace usage (memories, contexts, members, MCP calls/day)Viewer+

API-Key Bindings (2)

ToolDescriptionRequired Role
list_my_bindingsList your public-bound API keys (read-only; owner-scoped)Viewer+
describe_bindingDescribe one binding by key_id XOR context_id (read-only; owner-scoped)Viewer+

REST API

In addition to MCP tools, a full REST API is available:

  • Memory: remember, recall, reference, forget, explore (/api/v1/memory/*)
  • Contexts: CRUD, search settings (/api/v1/contexts/*)
  • Attachments: File upload/download for memories (/api/v1/attachments/*, 5MB limit)
  • Workspaces: Management, members, invitations (/api/v1/workspaces/*)
  • Admin: Users, plan management, neural config (/api/v1/admin/*)

Full API documentation: http://localhost:8080/redoc

Authentication

Two OAuth2 providers are supported:

  • Google OAuth2 — Required. Set GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET
  • GitHub OAuth2 — Optional. Set GITHUB_CLIENT_ID and GITHUB_CLIENT_SECRET

Users with the same email address across providers share a single account.

Plan Tier Customization

Plans control resource limits per workspace. Defaults:

PlanContextsMemoriesMCP calls/day
S (Free)11,0001,000
M (Basic)310,00010,000
L (Pro)20100,00050,000

Override via environment variables:

PLAN_FREE_MAX_CONTEXTS=5
PLAN_FREE_MEMORY_LIMIT=5000
PLAN_BASIC_MAX_CONTEXTS=10
PLAN_PRO_MAX_CONTEXTS=50

For self-hosted single-user setups, assign the L (Pro) plan to your workspace. Plan changes are admin-only by default. For SaaS deployments with self-service billing, enable Stripe:

BILLING_ENABLED=true
STRIPE_SECRET_KEY=sk_...
STRIPE_WEBHOOK_SECRET=whsec_...
STRIPE_PRICE_BASIC=price_xxx
STRIPE_PRICE_PRO=price_yyy

Development with Claude Code

This project is designed to be developed with Claude Code and Kagura Memory Cloud itself.

Getting Started with Claude Code

  1. Install Claude Code

  2. Clone the repo and start services (see Quick Start)

  3. Create an API key in the Web UI (http://localhost:3000)

  4. Create .mcp.json in the project root (see Claude Code setup)

    .mcp.json is in .gitignore — never commit it (contains API keys)

  5. Verify in Claude Code:

    > list_contexts()
    > create_context(name="my-project")
    
  6. Pre-configured tooling loads automatically from .claude/:

Slash Commands

Project-specific local commands (.claude/commands/):

CommandDescription
/setupSet up dev environment from scratch (detects WSL/macOS/Linux)
/remember <text>Save patterns, decisions, or learnings to memory
/recall <query>Search past knowledge for relevant patterns
/guideShow Kagura Memory Cloud usage guide
/testRun full test suite (backend pytest + frontend build)
/qualityRun all quality checks (ruff, pyright, frontend build)
/self-maintAudit .claude/ config against current codebase state
/api-docs-auditAudit OpenAPI tags and endpoint documentation

The issue→PR workflow lives in the kagura-plugins marketplace: /gh-issue-driven:start (branch + gate1 + recall), /kagura-code-reviewer (memory-grounded review), /gh-issue-driven:ship (gate2 + PR), /gh-issue-driven:review (post-PR loop).

Hooks (Automatic Safety Guards)

  • Auto-format: Python (ruff) / TypeScript (prettier) on every file save
  • Secret detection: Blocks commits containing hardcoded API keys or passwords
  • SQL injection prevention: Blocks f-string SQL queries (enforces SQLAlchemy)
  • .env protection: Prevents accidental modification of .env files
  • Migration protection: Prevents modification of lock files
  • Memory sync: Auto-syncs Claude Code memory files to Kagura Memory Cloud (details)

Agents

  • code-reviewer: Read-only code review against project standards (runs on Sonnet)
  • test-runner: Test execution, failure diagnosis, and auto-fix (runs on Sonnet)

Rules (Auto-loaded Context)

  • rules/backend.md: FastAPI/Python patterns, async requirements, testing conventions
  • rules/frontend.md: Next.js/TypeScript patterns, Tailwind, SWR conventions
  • rules/security.md: Auth requirements, RBAC, SQL safety, CORS policy

Documentation

API reference — two complementary entry points:

  • Concepts (markdown): API Reference — auth, base URLs, MCP endpoint, request/response examples
  • Endpoint reference (live): http://localhost:8080/redoc — auto-generated from FastAPI, always in sync with the running backend

Concepts & guides:

🇯🇵 日本語ガイド / Japanese Guide

インストール

# マーケットプレイスから追加
/plugin marketplace add kagura-ai/memory-cloud
/plugin install kagura-memory@kagura-memory-cloud

利用可能なスキル

スキル説明
/kagura-memory:session-start前回のセッションコンテキストを復元
/kagura-memory:session-summaryセッション終了前に知識を保存
/kagura-memory:recall過去の知識を検索
/kagura-memory:remember新しい知識を保存
/kagura-memory:guide使い方ガイド・接続確認・セットアップ
/kagura-memory:smoke-test全MCPツールの動作確認

推奨ワークフロー

/kagura-memory:session-start       # ← ここから:前回のコンテキストを復元
  ... 通常の作業 ...
/kagura-memory:recall              # 過去の設計判断・パターン・修正を検索
/kagura-memory:remember            # 重要な学びを都度保存
  ... 作業完了 ...
/kagura-memory:session-summary     # ← ここで終了:次回のためにセッション知識を保存

スキルは MCP ツール(recall, remember など)をワークフローロジックで包んだものです。コンテキスト選択、git 状態の分析、構造化プロンプトが組み込まれています。セッション管理やガイド付きワークフローにはスキルを、細かい操作には MCP ツールを直接使ってください。

前提条件: MCP接続の設定が必要です(.mcp.json に API キーを設定)。プロジェクトで /kagura-memory:guide を実行してセットアップしてください。

Contributing

See CONTRIBUTING.md for development setup, code style, and PR workflow.

License

Apache License 2.0

Ver o original no GitHub

Bom para

Relacionados