de en es ja ko ru zh

Mnemosyne

Name: Mnemosyne
Author: M4F-S

by M4F-S

Overview Schema Related Servers Score Discussions

Python

Local

Mnemosyne 🧠

PyPI version Python 3.9+ MCP License: Apache-2.0

자율 AI 에이전트를 위한 프로덕션 등급의 로컬 우선 계층형 메모리 엔진.

Mnemosyne는 AI 에이전트(Hermes, OpenClaw, OpenManus, Claude Desktop, Cursor, Windsurf, CrewAI, LangChain)에게 영구적이고 구조화된 장기 메모리를 제공합니다. 사람이 읽을 수 있는 Obsidian Markdown Vault와 고속 PostgreSQL + pgvector (HNSW) 또는 설정이 필요 없는 SQLite를 연결하여, 하이브리드 Reciprocal Rank Fusion (RRF) 검색, wikilink 지식 그래프, Ebbinghaus 시간 감쇠, 다중 에이전트 플릿 공유, 비동기 Google Drive 클라우드 동기화를 지원합니다.

📑 목차

Related MCP server: Synapto

⚡ 전체 기능 매트릭스

기능	설명	이점
🤖 MCP 네이티브 (v2024-11-05)	표준화된 stdio JSON-RPC 프로토콜 서버	Claude, Cursor, Windsurf, Hermes, OpenClaw에 원활한 드롭인 제공
🔎 고재현율 HNSW 벡터 검색	`pgvector` HNSW 인덱싱과 `vector_cosine_ops` (`m=16, ef_construction=64`)	클러스터 재학습 없이 서브밀리초 벡터 재현
⚖️ 하이브리드 RRF 검색	Dense Embeddings (1.0) + GIN FTS (0.8) + Graph (0.6) + Salience (0.2)의 Reciprocal Rank Fusion	정확한 기술 키워드(CVE, 코드 토큰) 및 퍼지 의미론 모두 포착
🏛️ Wing 및 Room 범위 지정	2단계 분류 체계 (`wing` = 도메인/프로젝트, `room` = 채널/토픽)	컨텍스트 창 비대화 및 도메인 간 환각 제거
🌐 에이전트 간 공유 메모리	자격 증명 스크리닝을 갖춘 다중 에이전트 플릿에서 쿼리 가능한 중앙 `shared_db`	개인 데이터베이스를 손상시키지 않는 집단적 플릿 지능
☁️ 비동기 Google Drive 동기화	MD5 diffing 및 `.conflict.md` 브랜치 해결을 갖춘 로컬 우선 양방향 동기화 엔진	로컬에서 서브밀리초 에이전트 I/O + 자동 클라우드 백업 및 팀 공유
⏳ Ebbinghaus 시간 감쇠	90일 자동 아카이브와 함께 지수 감쇠 $Salience_t = Salience_0 \times (0.95)^{\Delta t}$	활성 메모리는 선명하게 유지하면서 일시적 노이즈 자동 정리
📌 고정 메모리 면역	`pinned=True` 또는 `#pinned` 태그를 통한 감쇠 영구 면역	기본 지침과 핵심 규칙이 절대 사라지지 않음 보장
📖 Obsidian Zettelkasten	YAML frontmatter 및 `[[Wiki Links]]`가 포함된 사람이 읽을 수 있는 Markdown 노트 작성	Obsidian에서 직접 시각적 검사, 편집 및 그래프 시각화
📜 턴 인지 수집기	턴 경계를 따라 200자 오버랩이 있는 1,500자 슬라이딩 윈도우 청킹	코드 블록을 깨지 않고 전체 대화 기록 보존
🛡️ 프롬프트 인젝션 아머	제어 토큰 (`<	im_start	>`,` [INST]`)을 산문에서 중화; XML 컨텍스트 태그 이스케이프	메모리 오염 및 컨텍스트 하이재킹 공격 방지
⚡ FastEmbed ONNX 지원	초경량 ONNX 런타임 임베딩 엔진 (~30MB RAM)	무거운 PyTorch `sentence-transformers` 대비 90% 메모리 절감
🔄 제로 설정 SQLite 폴백	PostgreSQL 오프라인 시 로컬 SQLite로 자동 폴백	독립 개발자 워크스테이션을 위한 100% 기능 동등성

🏗️ 시스템 아키텍처

                                ┌──────────────────────────────────────────────┐
                                │          AI Agents & LLM Frameworks          │
                                │  Hermes • OpenClaw • Claude • Cursor • Manus │
                                └──────────────────────┬───────────────────────┘
                                                       │ JSON-RPC (stdio) / Python SDK
                                                       ▼
┌─────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│                                           Mnemosyne Core (v3.4.0)                                           │
│                                                                                                             │
│  ┌─────────────────────────┐  ┌─────────────────────────┐  ┌─────────────────────────────────────────────┐  │
│  │ Admission & Security    │  │ Multi-Backend Embedder  │  │ Turn-Aware Session Ingestor                 │  │
│  │ - Secret Regex Guard    │  │ - FastEmbed (ONNX 30MB) │  │ - Turn boundary splitting                   │  │
│  │ - Injection Neutralizer │  │ - Remote Microservice   │  │ - 1500-char linear sliding window           │  │
│  │ - Path Traversal Guard  │  │ - SentenceTransformers  │  │ - Sequential [[Wiki Link]] chaining         │  │
│  └─────────────────────────┘  └─────────────────────────┘  └─────────────────────────────────────────────┘  │
│                                                                                                             │
│  ┌───────────────────────────────────────────────────────────────────────────────────────────────────────┐  │
│  │                                 Hybrid RRF Retrieval & Graph Ranker                                   │  │
│  │            RRF Score = 1.0 * Dense(HNSW) + 0.8 * Keyword(FTS) + 0.6 * Graph + 0.2 * Salience          │  │
│  └───────────────────────────────────────────────────────────────────────────────────────────────────────┘  │
└───────────────────────────────────────┬───────────────────────────────────────┬─────────────────────────────┘
                                        │                                       │
                ┌───────────────────────┴───────────────────────┐               │
                ▼                                               ▼               ▼
 ┌─────────────────────────────┐                 ┌─────────────────────────────────────────────┐
 │    PostgreSQL + pgvector    │                 │       Obsidian Markdown Vault (Local)       │
 │ - HNSW vector_cosine_ops    │                 │ - Human-Readable Markdown + YAML Frontmatter │
 │ - GIN tsvector English FTS  │                 │ - [[Wikilink]] Knowledge Graph Visualizer   │
 │ - Self-Healing DB Pool      │                 │ - Atomic Writes with EXDEV Fallback         │
 │ - Private DB + shared_db    │                 └──────────────────────┬──────────────────────┘
 └─────────────────────────────┘                                        │ Async Background Sync
                                                                        ▼
                                                 ┌─────────────────────────────────────────────┐
                                                 │              Google Drive Cloud             │
                                                 │ - Service Account / OAuth2 Authentication    │
                                                 │ - MD5 Checksum Verification                 │
                                                 │ - Sibling .conflict-TIMESTAMP.md Resolution │
                                                 └─────────────────────────────────────────────┘

🧠 핵심 기능 심층 분석

1. 계층형 Wing 및 Room 분류 체계

메모리 교차 오염은 다중 에이전트 플릿의 주요 실패 모드입니다. Mnemosyne는 메모리를 2단계 물리적 궁전으로 구조화합니다:

wing (도메인/프로젝트): 최상위 도메인 경계 (예: ecommerce, pentest, devops, shared).
room (토픽/채널): 세분화된 토픽 파티션 (예: database, firewall, stripe_api).

쿼리는 특정 wing 또는 room으로 좁게 범위를 지정할 수 있어, 마케팅 프롬프트가 침투 테스트 결과를 회상하는 것을 방지합니다.

2. 하이브리드 Reciprocal Rank Fusion (RRF) 검색

표준 벡터 검색은 정확한 기술 문자열(예: CVE-2024-38077, 0x7fff5fbff8c0)에서 실패하고, 키워드 검색은 의미론적 개념에서 실패합니다. Mnemosyne는 다중 후보 검색을 실행하고 가중 RRF를 사용하여 결과를 병합합니다:

$$\text{RRF Score}(d) = \sum_{m \in \text{modes}} w_m \cdot \frac{1}{k + \text{rank}_m(d)} + 0.2 \cdot \text{Salience}(d)$$

Dense HNSW 벡터 검색: 가중치 $1.0$ (384차원 임베딩에 대한 코사인 거리).
PostgreSQL 전문 검색: 가중치 $0.8$ (제목을 A로, 내용을 B로 가중치를 둔 tsvector).
재귀 그래프 탐색: 가중치 $0.6$ (1홉 및 2홉 [[Wiki Links]]를 발견하는 재귀 CTE).
메모리 Salience 엔진: 가중치 $0.2$ ($0.0$에서 $1.0$ 사이의 중요도 점수).

3. 에이전트 간 공유 메모리 레이어 (`shared_db`)

자율 다중 에이전트 환경에서 에이전트는 상태 손상을 방지하기 위해 격리된 개인 데이터베이스(toy_db, old_db, candy_db 등)를 유지합니다. 그러나 집단 지능은 글로벌 정책과 검증된 사실의 공유를 요구합니다.

게시: memory_publish_shared를 사용하여 검증된 노트가 shared_db에 게시됩니다.
자격 증명 스크리닝: 콘텐츠는 Anthropic 키(sk-ant-), Google Gemini 키(AIza...), HuggingFace 토큰(hf_...), OpenAI 키(sk-proj-...), AWS 액세스 키(AKIA...), Slack 토큰(xox-) 및 개인 키에 대한 엄격한 정규식 필터로 검사됩니다.
Fail-Soft 회상: 에이전트가 메모리를 쿼리할 때 memory_recall은 개인 저장소와 shared_db를 모두 쿼리합니다. 공유 데이터베이스에 일시적으로 접근할 수 없는 경우, 에이전트를 중단하지 않고 우아하게 성능이 저하됩니다.

4. Ebbinghaus 시간 감쇠 및 고정(Pinned) 면역

메모리는 시간이 지남에 따라 자연스럽게 관련성을 잃습니다. Mnemosyne는 Herman Ebbinghaus의 지수 망각 곡선을 구현합니다:

$$\text{Salience}(t) = \text{Salience}0 \times (0.95)^{\Delta t{\text{days}}}$$

터치 피드백: 메모리에 접근하면 last_accessed_at이 업데이트되어 감쇠가 재설정됩니다.
야간 자동 아카이빙: 통합 프로세스는 $\text{Salience} < 0.05$이고 $>90\text{ 일}$ 동안 접근되지 않은 노트를 자동으로 status = 'archived'로 전환합니다.
고정 면역: 시스템 규칙, 핵심 정책 또는 pinned=True로 표시되거나 #pinned 태그가 지정된 노트는 시간 감쇠로부터 영구 면역($\text{Salience} = 1.0$)을 받습니다.

5. Obsidian Markdown Vault 및 양방향 그래프

에이전트가 생성한 모든 메모리는 Obsidian vault 내부에 사람이 읽을 수 있는 .md 파일로 동시에 작성됩니다:

Zettelkasten Frontmatter: title, date, tags, type, salience, wing, room을 포함합니다.
지식 그래프: [[Target Note]]로 언급된 대상 노트는 PostgreSQL에서 양방향 엣지로 자동 파싱됩니다.
실시간 검사: 데스크톱 또는 모바일 장치에서 Obsidian을 열고 Obsidian의 대화형 그래프 뷰에서 에이전트 플릿의 집단 메모리를 탐색하세요.

6. 턴 인지(Turn-Aware) 축어적 세션 수집기

대화 기록에는 손실 압축에서 사라지는 중요한 뉘앙스가 자주 포함됩니다. memory_ingest_session:

원시 대화록을 턴 경계(User:, Assistant:, ### Turn, **Human**:)를 따라 분할합니다.
1,500자를 초과하는 턴에는 선형 슬라이딩 윈도우(200자 오버랩이 있는 1,500자)를 적용합니다.
[[Session ... Turn 01 Part 02]] wikilink를 사용하여 순차적 청크를 연결하여 코드 블록, 실행 추적 및 대화 흐름을 보존합니다.

7. 비동기 Google Drive 클라우드 동기화

에이전트 vault를 여러 머신 또는 모바일 장치에서 안전하게 백업하고 동기화하세요:

로컬 우선 속도: 에이전트 도구 호출이 Google Drive 네트워크 지연에 블로킹되지 않고 로컬 SSD 속도(<1ms)로 실행됩니다.
백그라운드 데몬 / Cron 동기화: 볼트 파일을 스캔하고 MD5 체크섬을 계산한 후 Google Drive와 델타를 양방향 동기화합니다.
충돌 해결: Google Drive와 로컬 에이전트 볼트에서 파일이 동시에 수정된 경우, Mnemosyne는 수신 버전을 NoteName.conflict-YYYYMMDD-HHMMSS.md로 저장하여 데이터 손실을 방지합니다.
인증: Google Cloud 서비스 계정 JSON(GOOGLE_APPLICATION_CREDENTIALS, GDRIVE_SERVICE_ACCOUNT_JSON) 및 OAuth2 사용자 토큰(GDRIVE_TOKEN_JSON)을 지원합니다.

8. 유연한 임베딩 백엔드 (FastEmbed / 마이크로서비스 / 로컬)

Mnemosyne는 어떤 배포 리소스 예산에도 적응합니다:

FastEmbed ONNX Runtime (독립형 노드 권장): ONNX Runtime C++ 실행(~30MB RAM)을 사용합니다. PyTorch 오버헤드가 전혀 없습니다.
중앙 집중식 마이크로서비스 (mnemosyne.embed_service): 단일 전용 컨테이너에서 sentence-transformers를 호스팅하여 HTTP(MEMORY_EMBED_URL)를 통해 여러 에이전트 컨테이너에 서비스를 제공합니다.
로컬 SentenceTransformers: 독립형 PyTorch 실행(all-MiniLM-L6-v2, 384차원).
결정적 해시 폴백: 극도로 제약된 환경을 위한 제로-RAM 수학적 벡터 해시.

9. 심층 방어 보안 및 인젝션 아머

경로 탐색 면역: 이중 해석된 정규 경로 검사(is_relative_to)를 통해 파일 작업이 볼트 루트를 벗어날 수 없도록 보장합니다.
원자적 형제 파일 쓰기: 파일은 형제 임시 파일(.note.pid.tmp)에 기록된 후 원자적으로 이름이 변경되며, EXDEV 크로스 디바이스 볼륨 마운트에 대한 자동 폴백을 제공합니다.
제어 토큰 중화: 코드 블록을 그대로 보존하면서 산문에서 LLM 인젝션 토큰(<|im_start|>, <|system|>, [INST], <<SYS>>)을 중화합니다.
구조화된 XML 컨텍스트 캡슐화: 회상된 메모리는 내부 태그 이스케이프와 함께 <recalled_memory_context id="..." title="..." source="..."> 태그로 감싸져, 호스트 LLM이 회상된 메모리를 활성 시스템 지시와 혼동하지 않도록 보장합니다.

🛠️ MCP 도구 참조 (8개 도구)

8개 도구 모두 표준 MCP JSON-RPC stdio를 통해 에이전트에 기본적으로 노출됩니다:

1. `memory_remember`

볼트에 시맨틱 임베딩, 태그 및 계층적 스코프와 함께 개인 메모리 노트를 저장합니다.

{
  "title": "PostgreSQL HNSW Tuning",
  "content": "For datasets >10,000 vectors, use HNSW with m=16 and ef_construction=64 for optimal recall.",
  "tags": ["database", "pgvector", "performance"],
  "wing": "engineering",
  "room": "databases",
  "salience": 0.8,
  "pinned": true
}

2. `memory_publish_shared`

정제되고 검증된 발견 사항 또는 정책을 에이전트 간 공유 플릿 메모리(shared_db)에 게시합니다.

{
  "title": "Fleet Security Policy: SSL Verification",
  "content": "All internal agent HTTP requests must enforce SSL certificate validation.",
  "tags": ["security", "policy"],
  "wing": "shared",
  "room": "general"
}

3. `memory_recall`

하이브리드 RRF, HNSW 벡터, 키워드 또는 그래프를 사용하여 개인 및 공유 플릿 데이터베이스에서 메모리를 검색합니다.

{
  "query": "HNSW index configuration parameters",
  "mode": "hybrid",
  "top_k": 5,
  "scope": {
    "wing": "engineering",
    "room": "databases"
  },
  "include_shared": true
}

4. `memory_ingest_session`

전체 대화 기록을 턴 경계를 기준으로 원문 그대로 수집하고 청크로 분할합니다.

{
  "transcript": "User: How do we configure pgvector?\nAssistant: Use CREATE EXTENSION vector; then create an HNSW index.",
  "wing": "engineering",
  "room": "sessions"
}

5. `memory_timeline`

최근 메모리 작업(remember, recall, remind, consolidate)을 시간순으로 검사합니다.

{
  "limit": 20
}

6. `memory_history`

업데이트 전 특정 메모리 노트의 버전 기록 및 과거 편집 스냅샷을 확인합니다.

{
  "title": "PostgreSQL HNSW Tuning",
  "limit": 5
}

7. `memory_remind_me`

향후 예정된 알림 또는 반복 작업을 예약합니다.

{
  "title": "Rotate Database Credentials",
  "content": "Verify that all 5 agent connection pools are refreshed with new passwords.",
  "trigger_at": "2026-09-01T00:00:00Z",
  "recurring": "monthly"
}

8. `memory_audit`

실시간 메모리 상태 메트릭, 저장소 백엔드 상태, 요청 수 및 활성 윙을 확인합니다.

{}

🌐 멀티 에이전트 플릿 프로덕션 아키텍처

멀티 에이전트 프로덕션 환경(예: 5-에이전트 Hermes 플릿)에서 Mnemosyne는 내부 Docker 네트워크에서 에이전트 데이터베이스를 격리하면서 공유 인텔리전스를 제공합니다:

                                  ┌─────────────────────────────────────────┐
                                  │      Production VPS (${VPS_HOST})      │
                                  └────────────────────┬────────────────────┘
                                                       │
         ┌───────────────────┬──────────────────┼───────────────────┬──────────────────┐
         ▼                   ▼                  ▼                   ▼                  ▼
┌──────────────────┐┌──────────────────┐┌──────────────────┐┌──────────────────┐┌──────────────────┐
│   hermes-agent   ││ hermes-assistant ││ hermes-marketing ││  hermes-pentest  ││  hermes-trader   │
│      (Toy)       ││      (Old)       ││     (Candy)      ││     (Pencil)     ││      (Coin)      │
│   Database:      ││   Database:      ││   Database:      ││   Database:      ││   Database:      │
│     toy_db       ││     old_db       ││     candy_db     ││     pencil_db    ││     trader_db    │
└────────┬─────────┘└────────┬─────────┘└────────┬─────────┘└────────┬─────────┘└────────┬─────────┘
         │                   │                  │                   │                  │
         └───────────────────┴──────────────────┼───────────────────┴──────────────────┘
                                                │
                                                ▼
                               ┌───────────────────────────────────┐
                               │   PostgreSQL + pgvector (HNSW)    │
                               │   - Private DBs: toy_db, old_db.. │
                               │   - Shared DB:   shared_db        │
                               └───────────────────────────────────┘

🚀 빠른 시작 및 설치

1. 설치

# Standard installation
pip install mnemosyne-memory

# With Google Drive Cloud Synchronization support
pip install "mnemosyne-memory[gdrive]"

# With lightweight FastEmbed ONNX support (~30MB RAM)
pip install "mnemosyne-memory[fastembed]"

# Full installation (All extras + Dev dependencies)
pip install "mnemosyne-memory[dev,gdrive,fastembed,embed-service]"

2. Docker Compose로 실행

PostgreSQL + pgvector 컨테이너를 시작합니다:

docker compose up -d

3. MCP 서버 시작

# Standalone with local SQLite (Zero configuration)
python -m mnemosyne server

# With PostgreSQL + pgvector
MEMORY_DB_DSN="postgresql://mnemosyne:***@localhost:5432/my_agent_db" python -m mnemosyne server

🤖 에이전트 프레임워크 통합 레시피

1. Claude Desktop (`claude_desktop_config.json`)

{
  "mcpServers": {
    "mnemosyne": {
      "command": "python3",
      "args": ["-m", "mnemosyne", "server"],
      "env": {
        "MEMORY_VAULT_PATH": "/Users/username/Documents/Obsidian/AgentVault",
        "MEMORY_DEFAULT_WING": "claude"
      }
    }
  }
}

2. Cursor IDE (`.cursor/mcp.json`)

{
  "mcpServers": {
    "mnemosyne": {
      "command": "python3",
      "args": ["-m", "mnemosyne", "server"],
      "env": {
        "MEMORY_VAULT_PATH": "./.vault",
        "MEMORY_DEFAULT_WING": "codebase"
      }
    }
  }
}

3. Hermes 에이전트 (`~/.hermes/config.yaml`)

mcp_servers:
  obsidian_memory:
    command: python3
    args: ["-m", "mnemosyne", "server"]
    env:
      MEMORY_DB_DSN: "postgresql://mnemosyne:***@${DB_HOST}:5432/toy_db"
      MEMORY_SHARED_DSN: "postgresql://mnemosyne:***@${DB_HOST}:5432/shared_db"
      MEMORY_VAULT_PATH: "/opt/data/vault"

4. OpenClaw (`openclaw-config.yaml`)

plugins:
  mcp_servers:
    mnemosyne:
      command: "python3"
      args: ["-m", "mnemosyne", "server"]
      env:
        MEMORY_VAULT_PATH: "~/.openclaw/vault"
        MEMORY_DEFAULT_WING: "openclaw"

5. Python SDK 및 자율 에이전트 스크립트

from mnemosyne import UnifiedMemorySystem

mem = UnifiedMemorySystem(
    vault_path="~/.agent/vault",
    dsn="postgresql://mnemosyne:***@localhost:5432/agent_db",
    shared_dsn="postgresql://mnemosyne:***@localhost:5432/shared_db"
)

# Remember fact
mem.remember(
    title="Kubernetes Cluster Policy",
    content="Deployments in staging must specify resource memory limits.",
    wing="infrastructure",
    room="k8s",
    tags=["kubernetes", "policy"],
    pinned=True
)

# Hybrid recall
results = mem.recall(
    query="staging memory limits",
    mode="hybrid",
    scope={"wing": "infrastructure"}
)

for r in results:
    print(r["title"], "->", r["formatted_context"])

💻 전체 CLI 명령어 참조

Mnemosyne는 완전한 기능을 갖춘 관리 CLI를 포함합니다:

# 1. Store a memory note
python -m mnemosyne remember "API Architecture" "Uses Bearer JWT auth." --tags security auth --wing backend --room api --salience 0.8 --pinned

# 2. Publish shared fleet memory
python -m mnemosyne publish-shared "Global Production Policy" "Always check SSL certs." --wing devops

# 3. Search memories
python -m mnemosyne recall "JWT authentication" --mode hybrid --top-k 5 --wing backend

# 4. View activity timeline
python -m mnemosyne timeline --limit 20

# 5. Trigger Ebbinghaus decay & link reconciliation
python -m mnemosyne consolidate --decay-rate 0.95 --archive-threshold 0.05

# 6. Check system statistics & health
python -m mnemosyne stats

# 7. Synchronize with Google Drive (One-off pass)
python -m mnemosyne sync-gdrive --folder "My-Agent-Vault" --credentials service-account.json

# 8. Run Google Drive Sync as a background daemon
python -m mnemosyne sync-gdrive --daemon --interval 60

# 9. Run standalone Centralized Embedding Microservice
python -m mnemosyne embed-service --host 0.0.0.0 --port 8000 --model all-MiniLM-L6-v2

⚙️ 환경 변수 참조

변수	기본값	설명
`MEMORY_VAULT_PATH`	`~/.mnemosyne/vault`	로컬 Obsidian Markdown 볼트 디렉토리의 파일시스템 경로입니다.
`MEMORY_DB_DSN`	(없음)	PostgreSQL DSN(예: `postgresql://user:pass@host:5432/db`)입니다. 설정되지 않으면 SQLite를 사용합니다.
`MEMORY_SHARED_DSN`	(없음)	선택적 에이전트 간 공유 플릿 데이터베이스용 PostgreSQL DSN입니다.
`MEMORY_AGENT_NAME`	`local-agent`	멀티 에이전트 플릿 배포에서 원본 에이전트의 식별자입니다.
`MEMORY_EMBED_URL`	(없음)	원격 중앙 집중식 임베딩 마이크로서비스 URL입니다(예: `http://localhost:8000`).
`MEMORY_REQUIRE_POSTGRES`	`false`	PostgreSQL 실패 시 SQLite로 폴백하는 대신 오류를 발생시키려면 `true`로 설정합니다.
`GOOGLE_APPLICATION_CREDENTIALS`	(없음)	Google Drive 동기화를 위한 Google Cloud 서비스 계정 JSON 파일 경로입니다.
`GDRIVE_SERVICE_ACCOUNT_JSON`	(없음)	Google Cloud 서비스 계정 자격 증명의 문자열화된 JSON 콘텐츠입니다.
`GDRIVE_TOKEN_JSON`	(없음)	승인된 Google OAuth2 사용자 토큰의 문자열화된 JSON 콘텐츠입니다.
`TOKENIZERS_PARALLELISM`	`false`	stdio JSON-RPC 스트림 무결성을 유지하기 위해 HuggingFace 토크나이저 포크를 비활성화합니다.
`HF_HUB_DISABLE_PROGRESS_BARS`	`1`	MCP 스트림을 깨끗하게 유지하기 위해 stdio에서 진행률 표시줄을 비활성화합니다.
`HF_HUB_OFFLINE`	`0`	로컬 캐시를 사용하여 SentenceTransformers를 100% 오프라인으로 실행하려면 `1`로 설정합니다.
`TRANSFORMERS_OFFLINE`	`0`	transformers가 외부 HuggingFace 네트워크 요청을 하지 못하도록 하려면 `1`로 설정합니다.

🧪 테스트 및 벤치마크

Mnemosyne는 포괄적인 테스트 스위트(단위 테스트, 보안 인젝션 테스트, SQLite 테스트, 라이브 PostgreSQL pgvector 통합 테스트)를 유지합니다:

# Run all unit tests
pytest tests/ -v -m "not integration"

# Run full test suite including live PostgreSQL + pgvector tests
MEMORY_DB_DSN="postgresql://mnemosyne:***@localhost:5432/test_db" pytest tests/ -v

📄 라이선스

Apache-2.0 라이선스. 오픈 자율 에이전트 생태계를 위해 구축되었습니다. 전체 내용은 LICENSE를 참조하세요.

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

license - permissive license

quality

maintenance

How are these scores calculated?

Maintenance

–Maintainers

–Response time

1wRelease cycle

2Releases (12mo)

Commit activity

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Tools

View all tools

Related MCP Servers

aimemory
Knowledge & Memory RAG Systems
George3307
A
license
Not graded
quality
D
maintenance
Gives AI agents persistent memory with semantic search, automatic extraction, and memory decay, accessible via MCP protocol.
Updated 6 months ago (2026-02-20 22:53 UTC)
12
MIT
Synapto
Knowledge & Memory Search
ramonlimaramos
A
license
Not graded
quality
A
maintenance
Provides persistent, searchable memory for MCP-compatible agents, enabling recall by meaning, automatic decay, trust scoring, and cross-agent handoffs.
Updated 4 days ago (2026-08-27 15:11 UTC)
5
MIT
mcp-memory
Knowledge & Memory RAG Systems
oneKn8
A
license
A
quality
D
maintenance
Provides persistent memory with semantic search for MCP-based AI agents, enabling them to store and recall information across sessions using vector embeddings.
Updated 5 months ago (2026-03-23 14:16 UTC)
4
1
MIT
madb-mcp-server
Knowledge & Memory Autonomous Agents
spshkar84
F
license
Not graded
quality
B
maintenance
Provides persistent, causal memory for AI agents with semantic recall, causal tracking, and importance-based forgetting through MCP tools.
Updated 2 months ago (2026-07-07 04:22 UTC)

View all related MCP servers

Related MCP Connectors

XMemo
Shared, governed long-term memory for AI agents across tools and sessions via MCP and REST.
mcp
Your memory, everywhere AI goes. Build knowledge once, access it via MCP anywhere.
OpenAkashic
Shared long-term memory vault for AI agents with 20 MCP tools.

View all MCP Connectors

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/M4F-S/gomaa'

If you have feedback or need assistance with the MCP directory API, please join our Discord server