Claude Code 메모리 동기화 방법 살펴보기 - 상황별 선택 가이드

안녕하세요. 갓대희 입니다.

MCP(Model Context Protocol)를 활용해 Claude의 메모리를 공유하고, 여러 기기에서 동기화하는 방법에 대해 작성해보려 한다.

 

 

Claude Code나 Claude Desktop을 사용하다 보면 한 가지 아쉬운 점이 있다. 대화 중 쌓인 컨텍스트, 프로젝트에 대한 이해, 사용자의 코딩 스타일 등 "메모리"가 세션이나 기기를 넘어서 유지되지 않는다는 것이다.

팀에서 협업할 때는 더욱 문제가 된다. A 개발자가 Claude에게 설명한 프로젝트 컨텍스트를 B 개발자의 Claude도 알고 있다면 얼마나 편리할까? 이런 요구를 해결하기 위해 MCP 기반의 메모리 공유 솔루션들이 등장했다.

이 글에서는 Claude 메모리를 원격으로 공유하는 방법을 몇가지 다룰 예정인데, 각자의 상황에 맞는 최적의 솔루션을 선택할 수 있도록 도움이 되면 좋겠다. 

 

3줄 요약 (TL;DR)

• mcp-memory-service + Cloudflare  팀 협업에 최적, OAuth 2.1 지원, 글로벌 동기화
• Memory Bank + SSH : 가장 간단한 설정, 기존 SSH 인프라 활용, 추가 비용 없음
• 선택 기준 : 팀 협업 → Cloudflare, 개인/간단 → SSH, 로컬 전용 → OpenMemory

이 글의 구성

1. MCP 기본 개념 - MCP란 무엇인가, 아키텍처 개요
2. 전송 프로토콜 - stdio, SSE, Streamable HTTP 비교
3. 메모리 저장 방식 - 파일, SQLite, 벡터DB, 지식 그래프
4. 5가지 솔루션 상세 설정 - Cloudflare, SSH, OpenMemory, Docker, 서버리스
5. 종합 비교 분석 - 상황별 최적 솔루션 선택 가이드
6. 트러블슈팅 - 일반적인 문제 해결 방법
7. FAQ - 자주 묻는 질문

 

MCP(Model Context Protocol) 이해하기

메모리 공유 솔루션들을 이해하려면 먼저 MCP가 무엇인지 알아야 한다. MCP는 Anthropic이 2024년에 발표한 AI 도구 연결 표준 프로토콜이다.

공식 문서 출처
MCP는 AI 모델이 외부 도구, 데이터 소스, 서비스와 표준화된 방식으로 통신할 수 있게 해주는 프로토콜이다. 클라이언트(Claude)와 서버(도구/서비스) 간의 양방향 통신을 지원한다.
Model Context Protocol 공식 사이트 →

MCP 아키텍처

MCP 통신 구조

1. MCP 클라이언트: Claude Code, Claude Desktop, Cursor 등 AI 애플리케이션
2. MCP 서버: 메모리 저장, 파일 시스템, API 등 외부 기능 제공
3. 전송 프로토콜: 클라이언트와 서버 간 통신 방식
4. 도구(Tools): 서버가 제공하는 실행 가능한 기능들

MCP 메모리 공유 아키텍처

┌─────────────────────────────────────────────────────────────────────┐
│                      MCP 클라이언트 (Host)                          │
│         Claude Code, Claude Desktop, Cursor, VS Code 등            │
└─────────────────────────────────────────────────────────────────────┘
                                  │
              ┌───────────────────┼───────────────────┐
              │                   │                   │
              ▼                   ▼                   ▼
     ┌─────────────┐     ┌─────────────┐     ┌─────────────┐
     │   stdio     │     │ Streamable  │     │    SSE      │
     │   (로컬)    │     │    HTTP     │     │  (레거시)   │
     └──────┬──────┘     └──────┬──────┘     └──────┬──────┘
            │                   │                   │
            ▼                   ▼                   ▼
┌─────────────────────────────────────────────────────────────────────┐
│                        MCP Memory Server                            │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐               │
│  │  Cloudflare  │  │   Memory     │  │  mem0-server │    ...        │
│  │   + D1/Vec   │  │  Bank + SSH  │  │  + Neo4j     │               │
│  └───────┬──────┘  └───────┬──────┘  └───────┬──────┘               │
└──────────┼─────────────────┼─────────────────┼──────────────────────┘
           │                 │                 │
           ▼                 ▼                 ▼
   ┌──────────────┐  ┌──────────────┐  ┌──────────────┐
   │  Cloudflare  │  │    SSH       │  │   Neo4j +    │
   │  D1 + Vector │  │   Server     │  │   pgvector   │
   │    (클라우드) │  │  (원격/로컬)  │  │   (Docker)   │
   └──────────────┘  └──────────────┘  └──────────────┘

▲ MCP 메모리 서버는 다양한 전송 방식과 저장소를 지원하며, 팀원 간 메모리 공유를 가능하게 한다

 

전송 프로토콜 종류

MCP는 세 가지 전송 프로토콜을 지원한다. 메모리 공유에서 가장 중요한 부분이므로 정확히 이해해야 한다.

프로토콜	연결 방식	원격 지원	적합한 환경
stdio	로컬 프로세스	X	로컬 개발, 단일 사용자
SSE (레거시)	HTTP 지속 연결	O	기존 서버 환경
Streamable HTTP (권장)	HTTP POST/GET	O	서버리스, 팀 협업

💡 포인트
원격 메모리 공유를 위해서는 SSE 또는 Streamable HTTP 프로토콜이 필요하다. stdio는 로컬 프로세스 간 통신만 지원하므로 원격 공유에 부적합하다. Anthropic은 2025년부터 Streamable HTTP를 공식 권장하고 있으며, SSE는 향후 deprecated될 예정이다.

 

메모리 저장 방식

MCP 메모리 서버들은 다양한 저장 방식을 사용한다. 각 방식의 특성을 이해하면 솔루션 선택에 도움이 된다.

메모리 저장 방식 비교

• 파일 기반: Markdown/JSON 파일로 저장. 간단하지만 검색 성능 제한
• SQLite: 로컬 데이터베이스. 빠른 읽기/쓰기, 단일 파일
• 벡터 DB (pgvector, Cloudflare Vectorize): 시맨틱 검색 지원. "비슷한 내용" 검색 가능
• 지식 그래프 (Neo4j): 관계 기반 저장. 복잡한 연결 관계 표현

 

원격 메모리 공유 솔루션 개요

현재 사용 가능한 주요 원격 메모리 공유 솔루션 몇가지를 먼저 개괄적으로 살펴보자. 이후 각 솔루션별 상세 설정 방법을 다룬다.

솔루션	핵심 특징	적합한 사용자
mcp-memory-service + Cloudflare	하이브리드 백엔드, OAuth 팀 협업	팀 단위 협업이 필요한 조직
Memory Bank MCP + SSH	SSH 기반 파일 공유	기존 SSH 서버가 있는 개인/소규모 팀
OpenMemory MCP (Mem0)	로컬 우선, UI 대시보드	같은 PC에서 여러 AI 앱 사용자
mem0-server-mcp (Docker)	Neo4j 지식 그래프, 셀프 호스팅	인프라 관리 역량이 있는 팀
Cloud Run/Koyeb 배포	서버리스, 자동 스케일링	서버 관리 부담 없이 원격 공유

 

1. mcp-memory-service + Cloudflare

가장 완성도가 높은 솔루션이다. 로컬 SQLite의 빠른 읽기 속도와 Cloudflare의 글로벌 동기화를 결합한 하이브리드 아키텍처를 제공한다.

공식 문서 출처
mcp-memory-service v8.9.0은 자동 구성, 5ms 로컬 읽기 + 백그라운드 Cloudflare 동기화, OAuth 2.1 팀 협업 기능을 제공한다.
GitHub: doobidoo/mcp-memory-service →

사전 요구사항

• Node.js 18 이상
• Cloudflare 계정 (무료 티어 사용 가능)
• Claude Code 또는 Claude Desktop

 

Step 1: 기본 설치

# Python 설치 스크립트 사용 (권장)

git clone https://github.com/doobidoo/mcp-memory-service.git
cd mcp-memory-service
python install.py --storage-backend hybrid

# 또는 npx로 직접 실행

npx -y mcp-memory-service

 

Step 2: Cloudflare 설정

Cloudflare에서 D1 데이터베이스와 Vectorize 인덱스를 생성해야 한다.

Cloudflare 설정 순서

1. Cloudflare Dashboard 접속
2. Workers & Pages → D1에서 새 데이터베이스 생성
3. Workers & Pages → Vectorize에서 새 인덱스 생성
4. API Tokens에서 D1과 Vectorize 권한이 있는 토큰 발급

 

Step 3: 환경 변수 설정

.env 파일

실행 환경: Node.js 18+ | mcp-memory-service | Cloudflare 계정 필요

# 저장 백엔드 설정
MCP_MEMORY_STORAGE_BACKEND=hybrid

# Cloudflare 인증 정보
CLOUDFLARE_API_TOKEN=your_api_token_here
CLOUDFLARE_ACCOUNT_ID=your_account_id_here
CLOUDFLARE_D1_DATABASE_ID=your_d1_database_id
CLOUDFLARE_VECTORIZE_INDEX=your_vectorize_index_name

# HTTP 서버 활성화 (팀 협업용)
MCP_HTTP_ENABLED=true
MCP_HTTP_PORT=8000

# OAuth 2.1 활성화 (선택)
MCP_OAUTH_ENABLED=true

 

Step 4: Claude Code에 연결

# 로컬 stdio 방식

claude mcp add memory-service npx -y mcp-memory-service

# HTTP 방식 (팀 협업)

claude mcp add --transport http memory-service http://localhost:8000/mcp

 

Step 5: 팀 협업 설정 (Docker)

docker-compose.http.yml

실행 환경: Docker 20+ | Docker Compose v2 | 포트 8000 개방 필요

version: '3.8'
services:
  memory-service:
    image: doobidoo/mcp-memory-service:latest
    ports:
      - "8000:8000"
    environment:
      - MCP_MEMORY_STORAGE_BACKEND=hybrid
      - CLOUDFLARE_API_TOKEN=${CLOUDFLARE_API_TOKEN}
      - CLOUDFLARE_ACCOUNT_ID=${CLOUDFLARE_ACCOUNT_ID}
      - MCP_HTTP_ENABLED=true
      - MCP_OAUTH_ENABLED=true
    volumes:
      - memory_data:/app/data

volumes:
  memory_data:

# 팀 협업 서버 시작

docker-compose -f docker-compose.http.yml up -d

장점
• 5ms 로컬 읽기 속도 + 글로벌 Cloudflare 동기화
• OAuth 2.1로 엔터프라이즈급 팀 협업 지원
• 13개 이상의 AI 앱 호환 (Claude Code, VS Code, Cursor 등)
• 시맨틱 검색으로 관련 메모리 자동 검색

단점
• Cloudflare 계정 및 설정 필요 (초기 학습 곡선)
• 무료 티어 한도 초과 시 비용 발생 가능
• 복잡한 설정으로 빠른 시작에 부적합

[실제 테스트 필요]
• Cloudflare 무료 티어의 D1/Vectorize 요청 한도
• OAuth 2.1 설정 시 정확한 스코프 및 권한 구성
• 대용량 메모리 동기화 시 지연 시간

핵심 포인트

• 5ms 로컬 읽기 + Cloudflare 글로벌 동기화 하이브리드
• OAuth 2.1로 엔터프라이즈급 팀 협업 지원
• 가장 완성도 높은 솔루션, 단 초기 설정 복잡
• 추천 대상: 팀 단위 협업이 필요한 조직

> Cloudflare 설정이 부담된다면, 기존 SSH 서버를 활용하는 더 간단한 방법도 있다.

 

2. Memory Bank MCP + SSH

SSH를 통해 원격 서버에 메모리를 저장하는 가장 간단한 방법이다. 기존에 SSH 접근이 가능한 서버가 있다면 별도 설정 없이 빠르게 시작할 수 있다.

공식 문서 출처
Memory Bank MCP는 SSH를 통해 원격 서버에 메모리를 저장할 수 있다. 여러 프로젝트의 메모리를 중앙에서 관리하면서 적절한 격리를 유지한다. (SSH 지원 버전)
GitHub: aakarsh-sasi/memory-bank-mcp →

사전 요구사항

• Node.js 18 이상
• SSH 접근 가능한 원격 서버
• SSH 키 기반 인증 설정 (권장)

 

Step 1: 설치

# npx로 직접 실행 (설치 불필요)

npx @aakarsh-sasi/memory-bank-mcp --help

# 또는 글로벌 설치

npm install -g @aakarsh-sasi/memory-bank-mcp

 

Step 2: SSH 키 설정

# SSH 키가 없다면 생성

ssh-keygen -t ed25519 -C "memory-bank@your-machine"

# 원격 서버에 공개키 복사
ssh-copy-id user@your-server.com

# 접속 테스트
ssh user@your-server.com "echo 'SSH 연결 성공'"

 

Step 3: 원격 서버에 메모리 디렉토리 생성

# 원격 서버에서 실행

mkdir -p ~/memory-bank
chmod 700 ~/memory-bank

 

Step 4: Claude Desktop/Code 설정

claude_desktop_config.json (Claude Desktop)

실행 환경: Node.js 18+ | SSH 키 인증 필수 (비밀번호 인증 미지원) | 원격 서버 접근 권한

{
  "mcpServers": {
    "memory-bank": {
      "command": "npx",
      "args": [
        "-y", "@aakarsh-sasi/memory-bank-mcp",
        "--remote",
        "--ssh-key", "~/.ssh/id_ed25519",
        "--remote-user", "user",
        "--remote-host", "your-server.com",
        "--remote-path", "/home/user/memory-bank"
      ]
    }
  }
}

주의
SSH 비밀번호 인증은 지원되지 않습니다. 반드시 SSH 키 기반 인증을 설정해야 합니다.

 

Step 5: 멀티 프로젝트 구조

Memory Bank는 프로젝트별로 메모리를 격리하여 관리할 수 있다.

메모리 뱅크 디렉토리 구조

구조 설명: 프로젝트별 메모리 격리 | Markdown 기반 | Git 동기화 가능

~/memory-bank/
├── project-a/
│   ├── context.md
│   ├── decisions.md
│   └── progress.md
├── project-b/
│   ├── context.md
│   ├── decisions.md
│   └── progress.md
└── shared/
    └── common-patterns.md

장점
• 설정이 가장 간단함 (SSH만 있으면 됨)
• 기존 SSH 인프라 그대로 활용
• 파일 기반이라 디버깅 및 백업 용이
• 비용 발생 없음 (기존 서버 활용)

단점
• 시맨틱 검색 없음 (키워드 기반 검색만)
• SSH 보안 관리 필요
• 서버 다운 시 메모리 접근 불가
• 실시간 동기화 없음 (파일 단위 접근)

핵심 포인트

• 가장 간단한 설정 - SSH만 있으면 바로 시작
• 기존 인프라 활용으로 추가 비용 없음
• 파일 기반이라 디버깅/백업 용이
• 추천 대상: 기존 SSH 서버가 있는 개인/소규모 팀

> 원격 공유가 필요 없다면? 같은 PC의 여러 AI 앱 간 메모리 공유에 최적화된 솔루션도 있다.

 

3. OpenMemory MCP (Mem0 공식)

Mem0.ai에서 공식 제공하는 메모리 솔루션이다. 완전히 로컬에서 동작하면서 같은 PC의 여러 AI 앱 간 메모리를 공유할 수 있다.

공식 문서 출처
OpenMemory는 Mem0가 제공하는 로컬 우선 메모리 인프라로, MCP 호환 도구들 간에 메모리를 공유하는 통합 레이어를 제공한다. 모든 데이터는 로컬에 저장되며 클라우드로 전송되지 않는다.
Mem0 블로그: OpenMemory MCP 소개 →

참고: 로컬 전용 솔루션
OpenMemory는 원격 공유가 아닌 같은 PC 내 여러 AI 앱 간 메모리 공유를 위한 솔루션입니다. 팀 협업이나 기기 간 동기화가 필요하다면 다른 솔루션을 선택하세요.

 

사전 요구사항

• Docker 및 Docker Compose
• OpenAI API 키 (임베딩용)
• make (빌드 도구)

 

Step 1: 설치 및 빌드

# 방법 1: 원커맨드 설치 (권장)

curl -sL https://raw.githubusercontent.com/mem0ai/mem0/main/openmemory/run.sh | bash

# API 키와 함께 설치
curl -sL https://raw.githubusercontent.com/mem0ai/mem0/main/openmemory/run.sh | OPENAI_API_KEY=your_key bash

# 방법 2: 수동 빌드

git clone https://github.com/mem0ai/mem0.git
cd mem0/openmemory

# 환경 변수 설정
cp api/.env.example api/.env
# api/.env 파일에 OPENAI_API_KEY 설정

# 빌드 및 실행
make build
make up

 

Step 2: 서버 확인

# 서버 상태 확인

# MCP 서버: http://localhost:8765
# 대시보드 UI: http://localhost:3000
# API 문서: http://localhost:8765/docs

 

Step 3: Claude Desktop 설정

claude_desktop_config.json

실행 환경: Python 3.9+ | OpenMemory 서버 실행 중 | 포트 8765 사용

{
  "mcpServers": {
    "openmemory": {
      "command": "openmemory",
      "args": ["mcp"]
    }
  }
}

 

Step 4: 대시보드 활용

OpenMemory는 웹 기반 대시보드를 제공하여 저장된 메모리를 시각적으로 관리할 수 있다.

대시보드 기능

• 메모리 조회: 저장된 모든 메모리 목록 확인
• 메모리 추가/삭제: 수동으로 메모리 관리
• 클라이언트 관리: 어떤 앱에서 접근 가능한지 설정
• 검색: 시맨틱 검색으로 관련 메모리 찾기

장점
• Mem0 공식 지원으로 안정적
• 웹 UI 대시보드 내장
• 완전 무료, 완전 로컬 (프라이버시 보장)
• Cursor, Claude Desktop, Windsurf 등 크로스 앱 공유

단점
• 원격 공유 불가 (같은 PC 내 앱간만 공유)
• 팀 협업 지원 없음
• 다른 기기에서 접근 불가

주의사항
OpenMemory MCP는 "원격" 공유 솔루션이 아니다. 같은 컴퓨터에서 여러 AI 앱(Cursor, Claude Desktop 등)이 메모리를 공유하는 용도이다. 팀원 간 공유나 여러 기기 간 동기화가 필요하다면 다른 솔루션을 선택해야 한다.

핵심 포인트

• Mem0 공식 지원, 완전 무료, 완전 로컬
• 웹 UI 대시보드로 메모리 시각적 관리
• 원격 공유 불가 - 같은 PC 내 앱간만 공유
• 추천 대상: 같은 PC에서 여러 AI 앱(Cursor, Claude Desktop) 사용자

> 완전한 데이터 통제와 지식 그래프 기능이 필요하다면? Docker 기반 셀프 호스팅을 고려해 보자.

4. mem0-server-mcp (Docker 셀프 호스팅)

Neo4j 지식 그래프와 pgvector를 결합한 프로덕션급 메모리 서버다. Docker로 원격 서버에 배포하면 팀 전체가 공유할 수 있다.

공식 문서 출처
프로덕션 레디 MCP 서버로, Claude Code 및 기타 AI 어시스턴트에 지능형 메모리를 제공한다. async/await 아키텍처, 지식 그래프, 스마트 청킹, 엔터프라이즈 보안을 지원한다.
GitHub: subhashdasyam/mem0-server-mcp →

 

사전 요구사항

• Docker 및 Docker Compose
• 원격 서버 (VPS, AWS EC2, 등)
• LLM API 키 (OpenAI/Anthropic) 또는 Ollama (셀프 호스팅)

 

Step 1: 레포지토리 클론

git clone https://github.com/subhashdasyam/mem0-server-mcp.git
cd mem0-server-mcp

 

Step 2: 환경 변수 설정

.env 파일

실행 환경: Docker 20+ | LLM API 키 필요 (OpenAI/Anthropic/Ollama 중 택1)

# LLM 제공자 설정 (택 1)
# Option A: Ollama (완전 셀프 호스팅, 권장)
LLM_PROVIDER=ollama
OLLAMA_BASE_URL=http://192.168.1.2:11434  # 또는 http://ollama:11434 (Docker 네트워크)
OLLAMA_LLM_MODEL=qwen3:8b
OLLAMA_EMBEDDING_MODEL=qwen3-embedding:8b
OLLAMA_EMBEDDING_DIMS=4096

# Option B: OpenAI
# LLM_PROVIDER=openai
# OPENAI_API_KEY=sk-proj-...
# OPENAI_LLM_MODEL=gpt-4o

# 스마트 텍스트 청킹 (선택)
CHUNK_MAX_SIZE=1000
CHUNK_OVERLAP_SIZE=150

# 프로젝트 격리 모드
PROJECT_ID_MODE=auto

 

Step 3: 서비스 시작

# 공식 시작 스크립트 사용 (권장)

# 모든 서비스 시작 (PostgreSQL, Neo4j, Mem0 API, MCP 서버)
./scripts/start.sh

# 또는 docker-compose 직접 사용
docker-compose up -d

# 로그 확인
docker-compose logs -f

💡 start.sh가 하는 일
• PostgreSQL (pgvector) 시작
• Neo4j 지식 그래프 시작
• Mem0 REST API 서버 시작
• MCP 서버 시작
• 모든 서비스 헬스체크 대기

 

Step 4: Claude Code에서 연결

# HTTP 전송으로 원격 서버 연결

claude mcp add --transport http mem0-server https://your-server.com:8000/mcp \
  --header "Authorization: Bearer your_secure_token"

 

Ollama를 사용한 셀프 호스팅

외부 LLM API를 사용하지 않고 완전히 자체 서버에서 모든 것을 처리할 수 있다.

docker-compose.ollama.yml (추가 설정)

실행 환경: Docker 20+ | NVIDIA GPU (선택사항) | 포트 11434 사용

services:
  ollama:
    image: ollama/ollama:latest
    volumes:
      - ollama_data:/root/.ollama
    ports:
      - "11434:11434"
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]

volumes:
  ollama_data:

# Ollama 모델 다운로드

docker exec -it ollama ollama pull nomic-embed-text
docker exec -it ollama ollama pull llama3.2

장점
• Neo4j 지식 그래프로 복잡한 관계 표현
• Ollama 사용 시 완전 무료 (API 비용 없음)
• 100% 데이터 통제 (프라이버시 완벽 보장)
• 13개 MCP 도구 제공

단점
• Docker/서버 관리 지식 필요
• 초기 설정이 복잡함
• 서버 유지보수 비용 (VPS 등)
• GPU 서버 필요 (Ollama 사용 시)

핵심 포인트

• Neo4j 지식 그래프로 복잡한 관계 표현
• Ollama 사용 시 100% 데이터 통제 (API 비용 없음)
• Docker 기반 원커맨드 배포
• 추천 대상: 인프라 관리 역량이 있는 팀, 프라이버시 중시

> 서버 관리 부담을 줄이고 싶다면? 서버리스 배포라는 선택지도 있다.

 

5. Cloud Run/Koyeb 서버리스 배포

인프라 관리 부담 없이 MCP 서버를 원격으로 배포하는 방법이다. Streamable HTTP를 지원하는 플랫폼에 배포하면 Claude Code에서 바로 연결할 수 있다.

공식 문서 출처
Remote MCP 서버는 개발자가 로컬 서버 설정 없이 외부 도구와 리소스를 통합할 수 있게 해준다. 벤더가 업데이트, 스케일링, 가용성을 관리한다.
Google Cloud 블로그: Cloud Run MCP 배포 가이드 →

Google Cloud Run 배포

# Google Cloud CLI 설치 후

# 프로젝트 설정
gcloud config set project YOUR_PROJECT_ID

# Cloud Run에 배포 (인증 필수 - 권장)
gcloud run deploy mcp-memory-server \
  --source . \
  --region us-central1

# 로컬에서 프록시로 연결 (IAM 인증 자동 적용)
gcloud run services proxy mcp-memory-server --region us-central1 --port=3000

보안 경고
--allow-unauthenticated 옵션은 보안상 권장되지 않습니다. 누구나 인터넷에서 MCP 서버에 접근할 수 있게 됩니다.

권장 방법: IAM 기반 인증을 사용하고, gcloud run services proxy로 로컬에서 안전하게 연결하세요. Google Cloud 문서에서도 이 방식을 권장합니다.

 

Koyeb 배포

공식 문서 출처
Koyeb는 Streamable HTTP 전송을 사용해 원격 MCP 서버를 배포할 수 있는 서버리스 플랫폼이다.
Koyeb: Remote MCP Server 배포 튜토리얼 →

# Koyeb CLI로 배포

koyeb app create mcp-memory
koyeb service create mcp-memory/memory-server \
  --docker your-registry/mcp-memory:latest \
  --port 8000:http \
  --env MCP_HTTP_ENABLED=true

 

Claude Code 연결

# 배포된 서버에 연결

# Cloud Run
claude mcp add --transport http memory https://mcp-memory-server-xxxxx.run.app/mcp

# Koyeb
claude mcp add --transport http memory https://memory-server-xxxxx.koyeb.app/mcp

장점
• 인프라 관리 최소화 (서버리스)
• 자동 스케일링 (사용량에 따라)
• 글로벌 배포 용이
• 빠른 시작 (몇 분 내 배포)

단점
• MCP 서버 구현을 직접 해야 함 (또는 기존 것 포크)
• 종량제 비용 (사용량 예측 어려움)
• Cold start 지연 가능성
• 복잡한 백엔드 (Neo4j 등) 연동 어려움

[실제 테스트 필요]
• Cloud Run 무료 티어 한도 및 초과 비용
• Cold start로 인한 첫 요청 지연 시간
• Streamable HTTP 엔드포인트 정확한 경로 설정

핵심 포인트

• 서버리스로 인프라 관리 최소화
• 자동 스케일링, 글로벌 배포 용이
• Cold start 지연 가능성, 종량제 비용
• 추천 대상: 서버 관리 부담 없이 원격 공유하고 싶은 개인/팀

> 5가지 솔루션을 모두 살펴봤다. 이제 상황에 맞는 최적의 선택을 위한 종합 비교를 해보자.

 

종합 비교 분석

5가지 솔루션을 주요 기준별로 비교한다. 이 평가는 공식 문서와 GitHub README를 기준으로 한 것으로, 실제 환경에 따라 달라질 수 있다.

기준	mcp-memory +Cloudflare	Memory Bank +SSH	OpenMemory (Mem0)	mem0-server (Docker)	Cloud Run /Koyeb
설치 난이도	🟡 중	🟢 하	🟢 하	🟡 중	🔴 상
원격 공유	지원	지원	-(로컬)	지원	지원
팀 협업	OAuth 2.1	SSH 공유	-	토큰 인증	URL 공유
시맨틱 검색	지원	-	지원	지원	구현 의존
지식 그래프	-	-	-	Neo4j	구현 의존
프라이버시	-하이브리드	-자체 서버	-로컬	-자체 서버	-클라우드
비용	무료 티어 가능	SSH 서버 비용	무료	VPS 비용	종량제

※ 이 비교표는 각 솔루션의 공식 문서를 기준으로 작성되었으며, 실제 성능은 환경에 따라 다를 수 있다.

 

상황별 추천

언제 무엇을 선택해야 하나?

팀 협업이 필요할 때:

• mcp-memory-service + Cloudflare
  OAuth 2.1, 글로벌 동기화
• Memory Bank + SSH
  간단 설정, 기존 인프라 활용

개인 사용/로컬 공유:

• OpenMemory MCP
  같은 PC 내 앱간 공유
• mem0-server-mcp
  완전한 데이터 통제

💡 Tip: 처음 시작한다면 Memory Bank + SSH로 빠르게 시작하고, 팀 규모가 커지면 Cloudflare 솔루션으로 전환하는 게 일반적인 패턴이다.

 

트러블슈팅

문제: MCP 서버 연결 실패

• MCP 서버가 실행 중인지 확인 (프로세스 체크)
• 환경 변수 설정 확인 (API 토큰, 경로 등)
• 포트 충돌 여부 확인 (기본 포트: 8000)
• claude mcp list로 등록된 서버 확인

문제: Cloudflare 동기화 실패

• Cloudflare API 토큰 권한 확인 (D1, Vectorize 접근 권한)
• Account ID, Database ID 정확성 확인
• 무료 티어 요청 한도 초과 여부 확인

문제: SSH 연결 타임아웃

• SSH 키 경로 정확성 확인 (~/.ssh/id_ed25519)
• 원격 서버 방화벽 설정 확인
• ssh -v user@server로 상세 디버그

문제: Docker 컨테이너 시작 실패

• .env 파일 존재 및 형식 확인
• docker-compose logs로 에러 메시지 확인
• 볼륨 마운트 경로 권한 확인
• Neo4j/PostgreSQL 이미지 다운로드 완료 여부

 

자주 묻는 질문 ❓

Q: Claude Desktop과 Claude Code가 같은 메모리를 공유할 수 있나요?

A: 가능하다. mcp-memory-service나 OpenMemory MCP를 사용하면 두 앱이 동일한 MCP 서버에 연결하여 같은 메모리 데이터베이스를 공유할 수 있다. 각 앱의 MCP 설정에서 같은 서버를 지정하면 된다.

Q: 무료로 팀 협업이 가능한 솔루션은?

A: Memory Bank MCP + SSH가 가장 저렴하다. 기존에 SSH 서버가 있다면 추가 비용 없이 사용 가능하다. mcp-memory-service의 경우 Cloudflare 무료 티어 내에서 사용할 수 있지만, 트래픽이 많으면 비용이 발생할 수 있다.

Q: 가장 빠르게 시작할 수 있는 방법은?

A: OpenMemory MCP이다. curl -sL https://raw.githubusercontent.com/mem0ai/mem0/main/openmemory/run.sh | bash 한 줄로 설치 가능하다. 단, 원격 공유는 지원하지 않으므로 같은 PC 내 앱 간 공유만 가능하다.

Q: 프라이버시가 중요한데 어떤 솔루션을 선택해야 하나요?

A: OpenMemory MCP(완전 로컬) 또는 mem0-server-mcp(자체 서버)를 권장한다. 특히 mem0-server-mcp에서 Ollama를 사용하면 임베딩 생성도 로컬에서 처리되어 외부로 데이터가 전송되지 않는다.

Q: SSE와 Streamable HTTP의 차이는?

A: SSE(Server-Sent Events)는 HTTP 기반 지속 연결을 사용하는 레거시 방식이다. Streamable HTTP는 2025년 도입된 새 표준으로, 지속 연결 없이 HTTP POST/GET으로 통신한다. 서버리스 환경에 적합하고 더 효율적이며, Anthropic이 공식 권장하는 방식이다.

Q: 메모리에 민감한 정보가 저장되면 어떻게 되나요?

A: 메모리에 저장되는 내용은 선택적으로 관리할 수 있다. 대부분의 솔루션에서 저장할 정보를 명시적으로 지정하거나, 저장된 메모리를 삭제하는 기능을 제공한다. 민감 정보는 저장하지 않도록 주의가 필요하다.

참고 자료

• Model Context Protocol 공식 사이트 - MCP 스펙 및 가이드
• doobidoo/mcp-memory-service - Cloudflare 하이브리드 메모리 서비스
• aakarsh-sasi/memory-bank-mcp - SSH 기반 메모리 뱅크
• Mem0 OpenMemory MCP 소개 - 공식 Mem0 메모리 솔루션
• subhashdasyam/mem0-server-mcp - Docker 셀프 호스팅
• Claude Docs: Remote MCP Servers - Anthropic 공식 문서
• Google Cloud Run MCP 배포 가이드
• Koyeb Remote MCP 배포 튜토리얼