
Day2 Mcp And Context Sync
- 1.4k installs
- 18 repo stars
- Updated March 22, 2026
- ai-native-camp/camp-2
day2-mcp-and-context-sync is an agent skill that ai native camp day 2 mcp & context sync. mcp를 배우고 나만의 context sync 스킬을 만든다. "2일차", "day 2", "mcp", "context sync" 요청에 사용.
About
day2-mcp-and-context-sync is an agent skill from ai-native-camp/camp-2 that ai native camp day 2 mcp & context sync. mcp를 배우고 나만의 context sync 스킬을 만든다. "2일차", "day 2", "mcp", "context sync" 요청에 사용. # Day 2: MCP & Context Sync 이 스킬이 호출되면 아래 **STOP PROTOCOL**을 반드시 따른다. --- ## 용어 정리 이 스킬에서 사용하는 핵심 용어: | 용어 | 설명 | |------|------| | **MCP** | Model Context Protocol. AI와 외부 도구를 연결하는 오픈 표준. USB-C처럼 다양한 서비스를 하나의 규격으로 연결 | | **Host / Client / Server** | MCP의 3요소. Host=AI 앱(Claude Code), Client=연결 관리자, Server=외부 도구 제공자 | | **Transport** | MCP 서버 연 Developers invoke day2-mcp-and-context-sync during build/integrations work for ai & agent building tasks. The skill documents triggers, prerequisites, and step-by-step workflows grounded in SKILL.md.
- 이 스킬이 호출되면 아래 **STOP PROTOCOL**을 반드시 따른다.
- | **MCP** | Model Context Protocol. AI와 외부 도구를 연결하는 오픈 표준. USB-C처럼 다양한 서비스를 하나의 규격으로 연결 |
- | **Host / Client / Server** | MCP의 3요소. Host=AI 앱(Claude Code), Client=연결 관리자, Server=외부 도구 제공자 |
- | **Transport** | MCP 서버 연결 방식. HTTP(클라우드 서비스)와 stdio(로컬 실행) 2가지 |
- | **Plugin** | Skill + MCP + Hook + Agent를 묶은 패키지. 설치 한 줄이면 MCP 서버까지 자동 연결 |
Day2 Mcp And Context Sync by the numbers
- 1,414 all-time installs (skills.sh)
- +3 installs in the week ending Aug 5, 2026 (Skillselion tracking)
- Ranked #838 of 16,546 AI & Agent Building skills by installs in the Skillselion catalog
- Security screen: MEDIUM risk (skills.sh audit)
- Data as of Aug 5, 2026 (Skillselion catalog sync)
day2-mcp-and-context-sync capabilities & compatibility
- Capabilities
- 이 스킬이 호출되면 아래 **stop protocol**을 반드시 따른다. · | **mcp** | model context protocol. ai와 외부 도구를 연 · | **host / client / server** | mcp의 3요소. host=ai · | **transport** | mcp 서버 연결 방식. http(클라우드 서비스)와 · | **plugin** | skill + mcp + hook + agent를 묶은 패키
- Use cases
- orchestration
What day2-mcp-and-context-sync says it does
이 스킬이 호출되면 아래 **STOP PROTOCOL**을 반드시 따른다.
┌─ Phase A (첫 번째 턴) ──────────────────────────────┐
│ 1. references/에서 해당 블록 파일의 EXPLAIN 섹션을 읽는다 │
npx skills add https://github.com/ai-native-camp/camp-2 --skill day2-mcp-and-context-syncAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 1.4k |
|---|---|
| repo stars | ★ 18 |
| Security audit | 1 / 3 scanners passed |
| Last updated | March 22, 2026 |
| Repository | ai-native-camp/camp-2 ↗ |
What it does
AI Native Camp Day 2 MCP & Context Sync. MCP를 배우고 나만의 Context Sync 스킬을 만든다. "2일차", "Day 2", "MCP", "context sync" 요청에 사용.
Who is it for?
Developers working on ai & agent building during build tasks.
Skip if: Tasks outside AI & Agent Building scope described in SKILL.md.
When should I use this skill?
AI Native Camp Day 2 MCP & Context Sync. MCP를 배우고 나만의 Context Sync 스킬을 만든다. "2일차", "Day 2", "MCP", "context sync" 요청에 사용.
What you get
Completed ai & agent building workflow aligned with SKILL.md steps.
- MCP server configuration
- context-sync workflow setup
Files
Day 2: MCP & Context Sync
이 스킬이 호출되면 아래 STOP PROTOCOL을 반드시 따른다.
---
용어 정리
이 스킬에서 사용하는 핵심 용어:
| 용어 | 설명 |
|---|---|
| MCP | Model Context Protocol. AI와 외부 도구를 연결하는 오픈 표준. USB-C처럼 다양한 서비스를 하나의 규격으로 연결 |
| Host / Client / Server | MCP의 3요소. Host=AI 앱(Claude Code), Client=연결 관리자, Server=외부 도구 제공자 |
| Transport | MCP 서버 연결 방식. HTTP(클라우드 서비스)와 stdio(로컬 실행) 2가지 |
| Plugin | Skill + MCP + Hook + Agent를 묶은 패키지. 설치 한 줄이면 MCP 서버까지 자동 연결 |
| subagent | Claude가 다른 Claude를 불러서 일을 시키는 것. 여러 일을 동시에 처리할 때 사용 |
| Explore 에이전트 | 프로젝트 폴더 구조를 파악해주는 전문 subagent. 읽기 전용 |
| API | 서비스가 제공하는 데이터 창구. MCP가 없을 때 직접 코드로 데이터를 가져오는 방법 |
| 스킬(Skill) | Claude Code에게 특정 작업 방법을 가르치는 문서. Day 1 Block 3-2에서 체험한 것 |
| STUB | 나중에 채울 빈칸. "여기에 나중에 내용이 들어갑니다"라는 표시. Part B에서 블록마다 하나씩 채워나간다 |
| 스켈레톤 | 빈칸(STUB)만 있는 뼈대. 건물로 치면 철골 구조만 세운 상태 |
| frontmatter | 파일 맨 위에 ---로 감싼 정보 영역. 스킬의 이름, 설명, 트리거 등을 적는 곳 |
| YAML / JSON | 데이터를 정리하는 형식. 엑셀이 표로 데이터를 정리하듯, 텍스트로 정리하는 방식 |
| CLI | Command Line Interface. 터미널에 직접 명령어를 입력하는 방식 |
---
STOP PROTOCOL — 절대 위반 금지
이 프로토콜은 이 스킬의 최우선 규칙이다.
아래 규칙을 위반하면 수업이 망가진다.
각 블록은 반드시 2턴에 걸쳐 진행한다
┌─ Phase A (첫 번째 턴) ──────────────────────────────┐
│ 1. references/에서 해당 블록 파일의 EXPLAIN 섹션을 읽는다 │
│ 2. 기능을 설명한다 │
│ 3. references/에서 해당 블록 파일의 EXECUTE 섹션을 읽는다 │
│ 4. "지금 직접 실행해보세요"라고 안내한다 │
│ 5. ⛔ 여기서 반드시 STOP. 턴을 종료한다. │
│ │
│ ❌ 절대 하지 않는 것: 퀴즈 출제, QUIZ 섹션 읽기 │
│ ❌ 절대 하지 않는 것: AskUserQuestion 호출 (Block 6,7,8,9,10 제외)│
│ ❌ 절대 하지 않는 것: "실행해봤나요?" 질문 │
└──────────────────────────────────────────────────────────┘
⬇️ 사용자가 돌아와서 "했어", "완료", "다음" 등을 입력한다
┌─ Phase B (두 번째 턴) ──────────────────────────────┐
│ 1. references/에서 해당 블록 파일의 QUIZ 섹션을 읽는다 │
│ 2. AskUserQuestion으로 퀴즈를 출제한다 │
│ 3. 정답/오답 피드백을 준다 │
│ 4. 다음 블록으로 이동할지 AskUserQuestion으로 묻는다 │
│ 5. ⛔ 다음 블록을 시작하면 다시 Phase A부터. │
└──────────────────────────────────────────────────────────┘핵심 금지 사항 (절대 위반 금지)
1. Phase A에서 AskUserQuestion을 호출하지 않는다 (Block 6, 7, 8, 9, 10 제외) — 이 5개 블록은 사용자 선택/확인이 필수이므로 예외 2. Phase A에서 퀴즈를 내지 않는다 — QUIZ 섹션은 Phase B에서만 읽는다 3. Phase A에서 "실행해봤나요?"를 묻지 않는다 — 사용자가 먼저 말할 때까지 기다린다 4. 한 턴에 EXPLAIN + QUIZ를 동시에 하지 않는다 — 반드시 2턴으로 나눈다
공식 문서 URL 출력 (절대 누락 금지)
모든 블록의 Phase A 시작 시, 해당 reference 파일 상단의 > 공식 문서: URL을 반드시 그대로 출력한다.
📖 공식 문서: [URL]- reference 파일에 URL이 여러 개 있으면 전부 출력한다
- URL을 요약하거나 생략하지 않는다
- 참가자가 직접 클릭해서 공식 문서를 볼 수 있어야 한다
Phase A 종료 시 필수 문구
Phase A의 마지막에는 반드시 아래 형태의 문구를 출력하고 Stop한다:
---
👆 위 내용을 직접 실행해보세요.
실행이 끝나면 "완료" 또는 "다음"이라고 입력해주세요.이 문구 이후에 어떤 도구 호출(AskUserQuestion 포함)이나 추가 텍스트도 출력하지 않는다.
---
소요 시간
| Part | 블록 | 예상 시간 |
|---|---|---|
| Part A: MCP 딥다이브 | Block 0~4 | ~60분 |
| Part B: Context Sync 스킬 만들기 | Block 5~10 | ~110분 |
| 합계 | Block 0~10 | ~170분 |
---
핵심 전략
Part A: MCP 개념부터 Plugin까지 체계적으로 배우기
MCP의 개념(Block 0)부터 시작해서, 서버 추가(Block 1), 도구 탐색(Block 2), 인기 서버 설치(Block 3), Plugin으로 확장(Block 4)까지 순서대로 진행한다.
Part B: 4개 도구 × 4가지 연결 방법 — 점진적 빌드
아래 방식으로 진행한다:
1. Block 5에서 templates/context-sync.md 기반으로 4개 소스 STUB이 포함된 스켈레톤 스킬 파일을 생성한다 2. Block 6~9에서 블록마다 하나의 도구를 다른 연결 방법으로 연결하고, 해당 소스 STUB을 실제 내용으로 채운다 3. Block 10에서 실행 흐름 + 출력 포맷을 완성하고, 전체 스킬을 실행한다
핵심: 4개 도구를 일괄 연결하는 것이 아니라, 블록마다 다른 연결 방식을 실습한다.
Part B 블록 구조
| Block | 연결 방법 | 도구 | 난이도 | 시간 |
|---|---|---|---|---|
| 5 | — | 전체 | — | ~12min |
| 6 | claude.ai Connector | Slack | ★☆☆☆ | ~15min |
| 7 | claude mcp add | Notion | ★★☆☆ | ~18min |
| 8 | Official Plugin (/plugin) | Linear | ★★★☆ | ~15min |
| 9 | 커뮤니티 Plugin (구조 분석) | Google Calendar/Gmail | ★★★★ | ~20min |
| 10 | — (병렬 수집 + Output + 마무리) | 전체 | — | ~20min |
점진적 빌드 — 템플릿 채움 순서
Block 5: [STUB] [STUB] [STUB] [STUB] [STUB흐름] [STUB포맷]
Block 6: [Slack] [STUB] [STUB] [STUB] [STUB흐름] [STUB포맷]
Block 7: [Slack] [Notion] [STUB] [STUB] [STUB흐름] [STUB포맷]
Block 8: [Slack] [Notion] [Linear] [STUB] [STUB흐름] [STUB포맷]
Block 9: [Slack] [Notion] [Linear] [Google] [STUB흐름] [STUB포맷]
Block 10: [Slack] [Notion] [Linear] [Google] [완성흐름] [완성포맷] → 실행!블록-소스 매핑
| Block | 채우는 소스 | 연결 방법 | 스킬 파일 변경 영역 |
|---|---|---|---|
| 5 | — (골격 생성) | — | 전체 스켈레톤 생성 |
| 6 | 소스 1: Slack | Connector | 소스 1 STUB → 실제 내용 |
| 7 | 소스 2: Notion | claude mcp add | 소스 2 STUB → 실제 내용 |
| 8 | 소스 3: Linear | /plugin install | 소스 3 STUB → 실제 내용 |
| 9 | 소스 4: Google | 커뮤니티 Plugin | 소스 4 STUB → 실제 내용 |
| 10 | — (완성 + 실행) | — | 실행 흐름 + 출력 포맷 완성 |
---
블록 특수 규칙
Part A (Block 0~4)
- Block 4 [BONUS]: 시간이 남을 때만 진행한다
- Block 3 완료 후 Part A 마무리 안내 → Part B 전환 안내
- Part A에서 배운 MCP 지식이 Part B의 도구 연결(Block 7)에서 직접 활용된다
Part B (Block 5~10)
- Block 5 (스켈레톤 생성): Phase A에서 Context Sync 개념 + 4가지 연결 방법 소개 + Explore로 프로젝트 탐색 +
templates/context-sync.md기반 스켈레톤 생성 → Stop. Phase B에서 퀴즈. - Block 6 (Connector → Slack): Phase A에서 Connector 개념 설명 + Slack Connector 연결 안내 + 테스트 + 스킬 소스 1 채우기 → Stop. Phase B에서 퀴즈.
- Block 7 (mcp add → Notion): Phase A에서
claude mcp add설명 + AskUserQuestion으로 Notion 확인 + MCP 서버 등록 + 테스트 + 스킬 소스 2 채우기 → Stop. Phase B에서 퀴즈. - Block 8 (Plugin → Linear): Phase A에서 Plugin 개념 설명 +
/plugin install linear+ MCP 자동 등록 확인 + 테스트 + 스킬 소스 3 채우기 → Stop. Phase B에서 퀴즈. - Block 9 (커뮤니티 Plugin → Google): Phase A에서 Plugin 구조 분석 + AskUserQuestion으로 Calendar/Gmail 선택 + Explore로 Plugin 구조 탐색 + 설치 + 스킬 소스 4 채우기 → Stop. Phase B에서 퀴즈.
- Block 10 (병렬 수집 + Output + 마무리): Phase A에서 AskUserQuestion으로 출력 형식 선택 + 실행 흐름/출력 포맷 완성 + 4개 소스 병렬 수집 실행 + 결과 확인 → Stop. Phase B에서 종합 퀴즈 + 마무리.
AskUserQuestion 예외 블록
| Block | 이유 |
|---|---|
| Block 6 | Slack 사용 여부 확인 (회사 계정 제한 시 대안 안내) |
| Block 7 | Notion workspace 사용 여부 확인 |
| Block 8 | Linear 사용 여부 확인 (미사용 시 대안 Plugin 안내) |
| Block 9 | Google Calendar vs Gmail vs 둘 다 선택 |
| Block 10 | Output format 선택 |
Block 6 예외 규칙
Block 6의 Phase A는 AskUserQuestion을 사용한다. Slack 사용 여부와 연결 가능 여부를 확인해야 한다.
Slack 사용 시: 1. claude.ai/settings/connectors에서 Slack Connector 연결 2. /mcp로 claude.ai 섹션에 등록 확인 3. 연결 테스트 후 스킬 소스 1 채우기
Slack 미사용 또는 회사 계정 제한 시 (Plan B): 1. 개인 Slack workspace나 AI Native Camp Slack으로 연결 2. Connector 연결 방식 자체를 체험하는 것이 핵심임을 안내
⚠️ 보안 안내: 회사 Slack은 관리자 정책상 외부 앱 연결이 차단될 수 있다. 이 경우 개인 workspace를 사용한다.
Block 7 예외 규칙
Block 7의 Phase A는 AskUserQuestion을 사용한다. Notion 사용 여부를 확인해야 한다.
핵심 원칙: Claude가 설정을 대신 수행하고, 사용자는 결과를 확인한다.
Notion 사용 시: 1. claude mcp add --transport http notion https://mcp.notion.com/mcp 실행 2. /mcp로 local 섹션에 등록 확인 3. 연결 테스트 후 스킬 소스 2 채우기
Notion 미사용 시 (Plan B): 1. scripts/mcp_servers.py를 사용하여 대체 MCP 서버 검색 2. 검색 결과에서 선택하여 claude mcp add로 등록
Block 8 예외 규칙
Block 8의 Phase A는 AskUserQuestion을 사용한다. Linear 사용 여부를 확인해야 한다.
Linear 사용 시: 1. /plugin install linear 실행 2. /mcp로 local 섹션에 Linear MCP 자동 등록 확인 3. 연결 테스트 후 스킬 소스 3 채우기
Linear 미사용 시 (Plan B): 1. /plugin 명령어로 설치 가능한 다른 공식 Plugin 목록 확인 2. 사용 중인 도구의 Plugin이 있으면 그것을 설치 3. Plugin이 없으면 Block 8은 skip하고 Block 9로 이동 가능 4. 핵심: Plugin 설치 → MCP 자동 등록이라는 과정을 체험하는 것이 목표
⚠️ Plugin 설치 후 Claude Code 재시작이 필요할 수 있다. MCP 연결이 안 보이면 Claude Code를 재시작한다.
Block 9 예외 규칙
Block 9의 Phase A는 AskUserQuestion을 사용한다. Google Calendar vs Gmail vs 둘 다를 선택해야 한다.
Phase A 진행 순서: 1. references/block9-skill-google.md의 EXPLAIN 섹션을 읽고 Plugin 구조를 설명한다 2. /plugin marketplace add team-attention/plugins-for-claude-natives 실행 3. AskUserQuestion으로 Calendar/Gmail/둘 다/Skip 선택 4. Explore 에이전트로 Plugin 디렉토리 구조 탐색 + 설명 5. 선택한 도구 Plugin 설치 + 테스트 + 스킬 소스 4 채우기 → Stop
Block 10 예외 규칙
Block 10의 Phase A는 AskUserQuestion을 사용한다. Output format을 선택해야 한다.
---
References 파일 맵
Part A: MCP 딥다이브
| 블록 | 파일 | 주제 |
|---|---|---|
| Block 0 | references/block0-concept.md | MCP 개념 이해 |
| Block 1 | references/block1-add-server.md | MCP 서버 추가하기 |
| Block 2 | references/block2-mcp-command.md | /mcp 명령어로 도구 탐색 |
| Block 3 | references/block3-popular-servers.md | 인기 MCP 서버 탐색 및 설치 |
| Block 4 [BONUS] | references/block4-plugin-mcp.md | /plugin으로 MCP 확장 |
Part B: Context Sync 스킬 만들기 (4개 도구 × 4가지 연결 방법)
| 블록 | 파일 | 주제 |
|---|---|---|
| Block 5 | references/block5-template-creation.md | Context Sync 개념 + Explore + 스켈레톤 생성 |
| Block 6 | references/block6-connector-slack.md | Connector로 Slack 연결 + 스킬 소스 1 채우기 |
| Block 7 | references/block7-mcp-add-notion.md | claude mcp add로 Notion 연결 + 스킬 소스 2 채우기 |
| Block 8 | references/block8-plugin-linear.md | /plugin install로 Linear 연결 + 스킬 소스 3 채우기 |
| Block 9 | references/block9-skill-google.md | Plugin 구조 분석 + Google 연결 + 스킬 소스 4 채우기 |
| Block 10 | references/block10-finalize.md | 병렬 수집 + Output 선택 + 최종 실행 + 마무리 |
파일 경로는 이 SKILL.md 기준 상대경로다.
각 reference 파일은## EXPLAIN,## EXECUTE,## QUIZ섹션으로 구성된다.
---
Templates / Scripts 파일 맵
| 파일 | 용도 |
|---|---|
templates/context-sync.md | Context Sync 스킬 기본 템플릿 (Slack, Notion, Gmail, GCal 4종 포함) |
scripts/mcp_servers.py | GitHub에서 MCP 서버 검색 + README.md 파싱 + 설치 안내 |
Gmail/Calendar 등의 수집 스크립트는 Block 7에서 Claude가 사용자의 선택에 맞춰 직접 작성한다.
---
진행 규칙
- 한 번에 한 블록씩 진행한다
- "다음", "skip", 블록 번호/이름으로 이동한다
- BONUS 블록(Block 4)은 시간이 남을 때만 진행한다
- Part A(Block 0~4) 완료 후 Part B(Block 5~10)로 자연스럽게 전환한다. Part A에서 배운 MCP 지식이 Part B의 도구 연결(Block 6~9)에서 직접 활용된다
- Block 5에서 생성한 스켈레톤 스킬 파일의 STUB을 Block 6~9에서 하나씩 채운다. 각 블록에서 도구를 연결한 뒤 해당 소스 섹션을 실제 내용으로 교체한다
- 사용자 프로젝트의
.claude/skills/my-context-sync/디렉토리에 스킬을 생성한다 - Block 6~9에서 각각 Connector, mcp add, Plugin, 커뮤니티 Plugin을 통해 다른 연결 방식을 실습한다
- Explore 에이전트와 subagent 사용이 핵심이므로 적극 활용한다
- Claude Code 관련 질문이 오면 claude-code-guide 에이전트(내장 도구)로 답변한다. 답변 후 사용자가 직접 따라할 수 있게 단계별로 안내하고, 질문할 때는 AskUserQuestion을 사용한다. 내장 에이전트 답변이 부정확하다고 판단되면, 공식 문서를
curl로 파일에 저장한 뒤 Read 툴로 꼼꼼히 읽고 정확한 정보로 다시 답한다
---
시작
스킬 시작 시 먼저 최신 커리큘럼을 설치한 뒤 블록을 선택한다.
Step 1: 최신 스킬 설치
아래 명령어를 출력하고 Bash로 실행한다:
npx skills add ai-native-camp/camp-2 --agent claude-code --yes실행 결과를 간략히 안내한다 (예: "스킬이 최신 버전으로 설치되었습니다").
Step 2: 블록 선택
아래 테이블을 보여주고 AskUserQuestion으로 어디서 시작할지 물어본다.
Part A: MCP 딥다이브
| Block | 주제 | 내용 |
|---|---|---|
| 0 | MCP 개념 | MCP가 뭔지, USB-C 비유, 아키텍처 |
| 1 | 서버 추가 | claude mcp add로 실제 서버 연결 |
| 2 | /mcp 탐색 | 연결된 서버와 도구 목록 확인 |
| 3 | 인기 서버 | 공식 목록에서 유용한 서버 설치 |
| 4 [BONUS] | Plugin + MCP | /plugin으로 MCP 포함 플러그인 설치 |
Part B: 나만의 Context Sync 스킬 만들기 (4개 도구 × 4가지 연결 방법)
| Block | 연결 방법 | 도구 | 내용 |
|---|---|---|---|
| 5 | — | 전체 | Context Sync 개념 + 스켈레톤 생성 |
| 6 | Connector | Slack | 브라우저 클릭으로 Slack 연결 |
| 7 | claude mcp add | Notion | CLI 명령어로 Notion 연결 |
| 8 | Plugin (/plugin) | Linear | 공식 Plugin으로 Linear 연결 |
| 9 | 커뮤니티 Plugin | Plugin 구조 분석 + Google 연결 | |
| 10 | — | 전체 | 병렬 수집 + Output + 최종 실행 |
AskUserQuestion({
"questions": [{
"question": "Day 2: MCP & Context Sync\n\n어디서부터 시작할까요?",
"header": "시작 블록",
"options": [
{"label": "Part A: MCP 개념 (Block 0)", "description": "MCP가 뭔지, 왜 필요한지부터 시작"},
{"label": "Part A: 서버 추가 (Block 1)", "description": "MCP 개념을 알고 있어서 실습부터"},
{"label": "Part B: 스켈레톤 생성 (Block 5)", "description": "MCP를 이미 알고 있어서 스킬 만들기부터"},
{"label": "Part B: Notion 연결 (Block 7)", "description": "Slack은 연결했고, mcp add로 Notion 연결부터"}
],
"multiSelect": false
}]
})시작 블록 선택 후 → 해당 블록의 Phase A부터 진행한다.
Block 0: MCP 개념 이해
Phase A 시작 시 반드시 아래 형태로 출력한다:
```
📖 공식 문서: https://code.claude.com/docs/ko/mcp
📖 MCP 소개: https://modelcontextprotocol.io/introduction
```
EXPLAIN
MCP가 뭔가?
MCP = Model Context Protocol
AI 앱과 외부 도구를 연결하는 오픈 표준이다.
| 비유 | 설명 |
|---|---|
| USB-C | USB-C가 충전기, 모니터, 외장하드를 하나의 포트로 연결하듯, MCP는 Slack, Calendar, Notion을 하나의 규격으로 Claude에 연결한다 |
| 번역기 | Claude가 Slack의 언어, Notion의 언어를 각각 배울 필요 없이, MCP라는 공용어로 소통한다 |
MCP가 없으면 vs 있으면
MCP 없이 MCP로
┌──────────┐ ┌──────────┐
│ Claude │ │ Claude │
│ Code │ │ Code │
└────┬─────┘ └────┬─────┘
│ │ MCP (표준 규격)
│ ❌ 각각 다른 방식으로 │
│ 연결해야 함 ┌────┴────┐
│ │ MCP │
┌────┼──────┐ │ Server │
│ │ │ └────┬────┘
▼ ▼ ▼ │
Slack Notion Calendar ┌───────┼───────┐
(각각 다른 API) ▼ ▼ ▼
Slack Notion Calendar
(전부 같은 방식)3가지 핵심 요소
| 요소 | 역할 | 비유 |
|---|---|---|
| Host | AI 앱 (Claude Code) | 내 컴퓨터 |
| Client | 연결을 관리하는 중간자 | USB-C 포트 |
| Server | 외부 도구 제공자 | USB-C 기기 (모니터, 충전기) |
┌─────────────────────────────────┐
│ Host (Claude Code) │
│ │
│ ┌─────────┐ ┌─────────┐ │
│ │ Client 1│ │ Client 2│ │
│ └────┬────┘ └────┬────┘ │
└───────┼────────────┼────────────┘
│ │
┌────▼────┐ ┌────▼────┐
│ Slack │ │ Notion │
│ Server │ │ Server │
└─────────┘ └─────────┘MCP Server가 제공하는 3가지
| 종류 | 설명 | 예시 |
|---|---|---|
| Tools | Claude가 실행할 수 있는 기능 | "메시지 보내기", "파일 읽기" |
| Resources | Claude가 참조할 수 있는 데이터 | 데이터베이스 스키마, 파일 내용 |
| Prompts | 미리 만든 대화 템플릿 | "PR 리뷰해줘" 슬래시 명령 |
가장 많이 쓰는 건 Tools다. "Slack 메시지 읽어줘"라고 하면 Claude가 MCP를 통해 Slack Server의 Tool을 호출한다.
EXECUTE
Claude Code에 아래를 입력해서 MCP 개념을 확인해보자:
1. 현재 연결된 MCP 서버 확인:
/mcp/mcp를 입력하면 지금 내 Claude Code에 연결된 MCP 서버 목록이 나온다.
아직 아무것도 없어도 괜찮다. 다음 블록에서 추가한다.
2. MCP에 대해 Claude에게 물어보기:
MCP가 뭔지, 내가 쓸 수 있는 대표적인 MCP 서버 5개를 알려줘QUIZ
AskUserQuestion({
"questions": [{
"question": "MCP를 USB-C에 비유했습니다. MCP의 핵심 역할은?",
"header": "Quiz 0",
"options": [
{"label": "AI와 외부 도구를 표준 규격으로 연결", "description": "USB-C처럼 하나의 표준으로 다양한 도구를 꽂는 것"},
{"label": "Claude의 성능을 높이는 업그레이드", "description": "MCP는 성능이 아니라 연결의 문제를 해결"},
{"label": "코드를 자동으로 작성해주는 도구", "description": "MCP는 외부 서비스 연결 프로토콜"}
],
"multiSelect": false
}]
})정답: 1번. 피드백: "맞습니다! MCP = 표준 연결 규격. USB-C가 기기를 하나로 통일했듯, MCP는 AI와 외부 도구 연결을 하나로 통일합니다."
Block 1: MCP 서버 추가하기
Phase A 시작 시 반드시 아래 형태로 출력한다:
```
📖 공식 문서: https://code.claude.com/docs/ko/mcp
```
EXPLAIN
MCP 서버를 추가하는 3가지 방법
MCP 서버는 어디서 실행되느냐에 따라 추가 방법이 다르다.
| 방법 | 서버 위치 | 비유 | 언제 쓰나 |
|---|---|---|---|
| HTTP | 클라우드 | 웹사이트 접속 | Notion, Sentry 등 클라우드 서비스 |
| SSE | 클라우드 (구버전) | HTTP의 이전 버전 | 아직 HTTP 미지원인 서비스 |
| stdio | 내 컴퓨터 | 앱 설치 | 로컬 파일, DB 접근 |
핵심 명령어: claude mcp add
claude mcp add --transport [방법] [이름] [주소]이 명령어가 길어 보이지만, 한 단어씩 뜯어보면 간단하다:
| 입력 | 의미 | 비유 |
|---|---|---|
claude | Claude Code 실행 | "클로드야," |
mcp | MCP 기능 사용 | "MCP 관련해서," |
add | 서버를 추가해줘 | "하나 추가해줘" |
--transport | 연결 방식을 지정할게 | "연결 방법은..." |
http | HTTP 방식으로 | "웹으로 연결" |
notion | 이 서버의 이름(별명) | "이름은 notion이야" |
https://mcp.notion.com/mcp | 서버의 실제 주소 | "주소는 여기야" |
즉, "클로드야, MCP 서버 하나 추가해줘. HTTP 방식으로, 이름은 notion이고, 주소는 이거야" 라는 말이다.
방법 1: HTTP (가장 추천)
# Notion에 연결
claude mcp add --transport http notion https://mcp.notion.com/mcp
# Sentry에 연결
claude mcp add --transport http sentry https://mcp.sentry.dev/mcp방법 2: stdio (내 컴퓨터에서 실행)
# 파일 시스템 접근 서버
claude mcp add --transport stdio filesystem -- npx -y @modelcontextprotocol/server-filesystem /path/to/folder-- 뒤에 오는 건 MCP 서버를 실행하는 명령어다.서버 관리 명령어
| 명령어 | 동작 |
|---|---|
claude mcp list | 설치된 서버 목록 |
claude mcp get [이름] | 서버 상세 정보 |
claude mcp remove [이름] | 서버 제거 |
저장 범위 (scope)
| scope | 어디에 저장되나 | 누가 쓰나 |
|---|---|---|
local (기본) | 이 프로젝트에서만 | 나만 |
project | 프로젝트 폴더 (팀 공유) | 팀 전체 (git으로 공유) |
user | 내 컴퓨터 전체 | 모든 프로젝트에서 나만 |
# 모든 프로젝트에서 쓸 서버 추가
claude mcp add --transport http --scope user notion https://mcp.notion.com/mcp.mcp.json 파일이 뭔지 궁금할 수 있다. `claude mcp add` 명령어를 실행하면 Claude가 알아서 만들어주는 설정 파일이다. 직접 열어서 편집할 일은 거의 없다.<details> <summary>🔍 (참고) .mcp.json 파일의 구조가 궁금하다면</summary>
project scope로 서버를 추가하면 프로젝트 폴더에 .mcp.json 파일이 생긴다. 내용은 이런 형태다:
{
"mcpServers": {
"notion": {
"type": "http",
"url": "https://mcp.notion.com/mcp"
}
}
}이 파일을 git에 커밋하면 팀원도 같은 MCP 서버를 쓸 수 있다. 하지만 직접 편집할 필요는 없다. claude mcp add/remove 명령어가 이 파일을 자동으로 관리해준다.
</details>
EXECUTE
실제로 MCP 서버를 하나 추가해보자. 아래 중 하나를 선택해서 실행한다:
옵션 A: Context7 (프로그래밍 문서 검색 — 추천)
claude mcp add --transport stdio context7 -- npx -y @upstash/context7-mcp@latestContext7은 라이브러리 공식 문서를 실시간으로 검색해주는 MCP 서버다.
옵션 B: Notion (노션 사용자)
claude mcp add --transport http notion https://mcp.notion.com/mcp옵션 C: Fetch (웹페이지 가져오기)
claude mcp add --transport stdio fetch -- npx -y @anthropic-ai/mcp-fetch@latest설치 후 확인:
claude mcp list방금 추가한 서버가 목록에 보이면 성공!
Claude Code를 재시작해야 적용되는 경우가 있다. 새 세션을 시작해보자.
QUIZ
AskUserQuestion({
"questions": [{
"question": "클라우드 서비스(Notion, Sentry)에 연결할 때 추천하는 transport 방법은?",
"header": "Quiz 1",
"options": [
{"label": "HTTP", "description": "클라우드 서비스 연결의 표준 방식"},
{"label": "stdio", "description": "stdio는 내 컴퓨터에서 로컬 실행할 때 사용"},
{"label": "FTP", "description": "MCP에서 FTP는 지원하지 않음"}
],
"multiSelect": false
}]
})정답: 1번. 피드백: "정확합니다! 클라우드 = HTTP, 로컬 = stdio. 이 두 가지만 기억하면 됩니다."
Block 10: 병렬 수집 + Output + 마무리
Phase A 시작 시 반드시 아래 형태로 출력한다:
```
📖 공식 문서: https://code.claude.com/docs/ko/sub-agents
```
EXPLAIN
Block 5~9 정리
지금까지 4개 소스를 각각 다른 방법으로 연결했다:
Block 5: 스켈레톤 생성 (4개 STUB)
Block 6: Slack ← Connector (브라우저 클릭) ★☆☆☆
Block 7: Notion ← claude mcp add (CLI 명령어) ★★☆☆
Block 8: Linear ← Official Plugin (/plugin) ★★★☆
Block 9: Google ← 커뮤니티 Plugin (구조 분석) ★★★★4가지 연결 방법 총정리: 언제 어떤 방법?
| 상황 | 추천 방법 | 이유 |
|---|---|---|
| 해당 서비스가 Connector에 있다 | Connector | 가장 쉽고 빠르다 |
| HTTP MCP 서버 주소를 알고 있다 | `claude mcp add` | 명령어 한 줄이면 끝 |
| 공식 Plugin이 있다 | Plugin | MCP + 스킬 + 설정 한 번에 |
| 위 방법이 다 안 된다 | API 스크립트 (고급) | Claude가 코드를 작성 |
난이도 순서: Connector < mcp add < Plugin < API 스크립트 (고급)
유연성 순서: API 스크립트 > Plugin > mcp add > Connector
>
참고: API 스크립트는 고급 방법이다. 오늘 배운 4가지 방법으로 대부분의 도구를 연결할 수 있다.
병렬 수집이란?
여러 도구에서 동시에 정보를 가져오는 것이다.
카페로 비유해볼게요.
점심시간, 손님이 한꺼번에 몰린 카페를 상상해보세요.
직원 1명인 카페 (순차 수집)
- 한 명이 주문 받고 → 커피 만들고 → 디저트 준비하고 → 서빙
- 손님 4팀 처리에 40분
직원 4명인 카페 (병렬 수집)
- 한 명은 Slack, 한 명은 Notion, 한 명은 Linear, 한 명은 Google
- 각자 맡은 일만 집중 → 4팀 처리에 10분
❌ 순차 수집 (직원 1명): 120초
Slack(30초) → Notion(30초) → Linear(30초) → Google(30초)
✅ 병렬 수집 (직원 4명): 30초
Slack(30초) ─┐
Notion(30초) ├── 동시에!
Linear(30초) │
Google(30초) ─┘Claude는 Subagent(부하 직원)를 여러 명 동시에 부른다. Day 1에서 배운 그 subagent다.
출력 형식 옵션
수집한 정보를 어디에 내보낼 것인가?
| 옵션 | 설명 | 필요 조건 |
|---|---|---|
| Markdown 파일 (기본) | 프로젝트 폴더에 .md 파일로 저장 | 없음 (항상 가능) |
| + Slack 메시지 | 특정 채널에 요약 발송 | Slack MCP 연결 |
| + Notion 페이지 | DB에 새 페이지 생성 | Notion MCP 연결 |
Markdown은 기본으로 항상 포함하고, Slack이나 Notion을 추가하면 더 편리해진다. 여러 개를 동시에 쓸 수도 있다:
수집된 정보
├── Markdown 파일로 저장 (기록용) ← 항상 포함
├── Slack 채널로 전송 (공유용) ← 선택
└── Notion 페이지 생성 (축적용) ← 선택EXECUTE
Step 1: 출력 형식 선택
AskUserQuestion({
"questions": [{
"question": "수집 결과를 어떤 형식으로 출력할까요?\n\nMarkdown 파일은 기본으로 항상 포함됩니다.\n추가로 Slack이나 Notion 출력을 선택할 수 있습니다.",
"header": "출력 형식",
"options": [
{"label": "Markdown 파일만", "description": "프로젝트 폴더에 .md 파일로 저장 (가장 간단)"},
{"label": "Markdown + Slack 전송", "description": "파일 저장 + 특정 Slack 채널에 요약 발송"},
{"label": "Markdown + Notion 페이지", "description": "파일 저장 + Notion DB에 페이지 생성"},
{"label": "Markdown + Slack + Notion", "description": "세 곳 모두에 출력"}
],
"multiSelect": false
}]
})Step 2: 스킬 파일 실행 흐름 + 출력 포맷 완성
출력 형식 선택 결과에 따라 .claude/skills/my-context-sync/SKILL.md의 남은 STUB을 모두 채운다.
실행 흐름 섹션 완성:
각 소스별 Agent 호출을 구체화한다:
각 소스 수집은 subagent(Agent 도구)로 실행한다.
(아래는 Claude가 자동으로 실행합니다. 여러분이 입력할 필요 없습니다.)
Agent(description="Slack 수집", prompt="...", subagent_type="general-purpose")
Agent(description="Notion 수집", prompt="...", subagent_type="general-purpose")
Agent(description="Linear 수집", prompt="...", subagent_type="general-purpose")
Agent(description="Google 수집", prompt="...", subagent_type="general-purpose")
→ 4개를 동시에 호출 (병렬 실행)
→ 일부 소스가 연결되지 않은 경우, 연결된 소스만으로 수집 진행리포트 형식도 완성:
싱크 완료!
수집 결과:
Slack: 3개 채널, 47개 메시지 ✅
Notion: 15개 태스크 ✅
Linear: 8개 이슈 ✅
Google: 5개 일정, 12개 이메일 ✅
하이라이트 3건:
1. [Slack] #project-updates: 배포 일정 확정
2. [Linear] 마감 임박 이슈 2건
3. [Calendar] 내일 10시 팀 미팅
액션 아이템:
- [ ] 이메일 회신 2건
- [ ] Linear 이슈 마감일 확인
파일 저장: sync/2026-03-02-context-sync.md출력 포맷 섹션 완성:
선택에 따라 출력 포맷 섹션을 구체화한다.
Slack 포함 시:
mcp__claude_ai_Slack__slack_send_message(channel="{채널명}", content="{요약}")Notion 포함 시:
Notion MCP로 데이터베이스에 새 페이지 생성Step 3: 4개 소스 병렬 수집 실행
완성된 스킬을 실제로 실행한다.
Claude가 4개 subagent를 동시에 호출하여 수집을 시작한다:
[Slack 수집] 진행 중...
[Notion 수집] 진행 중...
[Linear 수집] 진행 중...
[Google 수집] 진행 중...Step 4: 결과 확인 + 리포트
수집 결과를 성공/실패로 구분하여 보여준다:
수집 결과:
Slack: ✅ 성공 (3개 채널, 47개 메시지)
Notion: ✅ 성공 (15개 태스크)
Linear: ❌ 실패 (원인: 인증 토큰 만료)
Google: ✅ 성공 (5개 일정)
성공: 3/4 소스실패한 소스가 있으면 원인을 분석하고 재시도를 안내한다.
성공한 소스만으로도 충분합니다. 4개 중 2~3개만 성공해도 Context Sync의 가치를 충분히 체험할 수 있다. 나머지 소스는 나중에 추가로 연결하면 된다.
Step 5: 축하 + 활용 팁
축하합니다! 나만의 Context Sync 스킬이 완성되었습니다!
오늘 배운 것:
✅ 4가지 연결 방법 (Connector, mcp add, Plugin, 커뮤니티 Plugin)
✅ 병렬 수집 (subagent로 동시에)
✅ 스킬 구축 (STUB → 점진적 완성)
이제 "싱크해줘" 한마디로 흩어진 정보가 자동으로 모입니다.
활용 팁:
1. 매일 아침 실행하면 "모닝 브리핑"처럼 사용할 수 있습니다
2. CLAUDE.md에 스케줄을 추가하면 매일 자동 실행도 가능합니다:
## 스케줄
- context-sync: 매일 09:00 실행
3. 소스를 추가하고 싶으면 스킬 파일에 같은 형식으로 넣으면 됩니다
4. Day 3 이후에 이 스킬을 더 발전시킬 수 있습니다QUIZ
Block 10은 종합 퀴즈를 출제한다. 사용자가 돌아오면 먼저 "Day 2의 모든 과정을 완료했습니다! 마지막으로 오늘 배운 것을 정리하는 퀴즈입니다." 라고 안내한 뒤 아래 퀴즈를 순서대로 출제한다.
Quiz 10-1: 병렬 수집
AskUserQuestion({
"questions": [{
"question": "\"병렬 수집\"의 가장 큰 장점은 무엇인가요?",
"header": "Quiz 10-1",
"options": [
{"label": "하나가 실패하면 전체가 멈춘다", "description": "오히려 독립 실행이라 다른 소스에 영향 없음"},
{"label": "여러 소스를 동시에 수집하여 시간을 절약한다", "description": "각 subagent가 독립적으로 동시 실행"},
{"label": "데이터를 더 정확하게 수집한다", "description": "정확도는 병렬/순차와 무관"}
],
"multiSelect": false
}]
})정답: 2번. 병렬 수집은 여러 소스를 동시에 수집하여 시간을 대폭 절약한다. 4개 소스를 순차적으로 하면 120초 걸릴 것을, 동시에 하면 30초면 된다.
Quiz 10-2: 출력 형식
AskUserQuestion({
"questions": [{
"question": "3가지 출력 형식 중 가장 간단하고, 외부 서비스 연결 없이 바로 쓸 수 있는 것은?",
"header": "Quiz 10-2",
"options": [
{"label": "Slack 메시지", "description": "Slack MCP 연결 필요"},
{"label": "Notion 페이지", "description": "Notion MCP 연결 필요"},
{"label": "Markdown 파일", "description": "프로젝트 폴더에 .md 파일로 저장"}
],
"multiSelect": false
}]
})정답: 3번 (Markdown 파일). 별도 설정 없이 바로 사용할 수 있어서 가장 간단하다. 그래서 기본 출력으로 항상 포함된다.
Quiz 10-3: 4가지 연결 방법
AskUserQuestion({
"questions": [{
"question": "오늘 배운 4가지 연결 방법을 난이도가 낮은 순서대로 나열하면?",
"header": "Quiz 10-3",
"options": [
{"label": "mcp add → Connector → Plugin → 커뮤니티 Plugin", "description": "Connector가 가장 쉬운 방법"},
{"label": "Connector → mcp add → Plugin → 커뮤니티 Plugin", "description": "Block 6 → 7 → 8 → 9 순서 그대로"},
{"label": "Plugin → Connector → mcp add → 커뮤니티 Plugin", "description": "Plugin이 가장 쉽지는 않음"}
],
"multiSelect": false
}]
})정답: 2번. Connector(클릭) → mcp add(명령어) → Plugin(패키지 설치) → 커뮤니티 Plugin(구조 이해까지) 순으로 난이도가 올라간다.
Quiz 10-4: Day 2 종합
AskUserQuestion({
"questions": [{
"question": "Day 2에서 배운 핵심 3가지를 고르세요.",
"header": "Quiz 10-4",
"options": [
{"label": "4가지 도구 연결 방법", "description": "Connector, mcp add, Plugin, 커뮤니티 Plugin"},
{"label": "HTML 코딩", "description": "Day 2에서 HTML은 다루지 않았음"},
{"label": "subagent 병렬 수집", "description": "여러 소스에서 동시에 정보 수집"},
{"label": "서버 배포", "description": "Day 2에서 배포는 다루지 않았음"},
{"label": "점진적 스킬 구축", "description": "STUB → 하나씩 채움 → 완성"}
],
"multiSelect": true
}]
})정답: 4가지 도구 연결 방법(1번), subagent 병렬 수집(3번), 점진적 스킬 구축(5번) — 3개 모두 선택 피드백: "완벽합니다! 4가지 방법으로 도구를 연결하고, subagent로 동시에 수집하고, STUB에서 시작해 점진적으로 스킬을 완성했습니다. 이 3가지가 Day 2의 핵심입니다. 내일부터는 이 스킬을 기반으로 더 발전시켜 나갑니다!"
Block 2: /mcp 명령어로 도구 탐색
Phase A 시작 시 반드시 아래 형태로 출력한다:
```
📖 공식 문서: https://code.claude.com/docs/ko/mcp
```
EXPLAIN
/mcp 명령어란?
Claude Code 안에서 /mcp를 입력하면 연결된 MCP 서버의 상태와 도구를 한눈에 볼 수 있다.
| 기능 | 설명 |
|---|---|
| 서버 목록 | 연결된 모든 MCP 서버 표시 |
| 연결 상태 | 각 서버의 연결/오류 상태 확인 |
| 도구 목록 | 각 서버가 제공하는 도구(Tools) 확인 |
| OAuth 인증 | 로그인이 필요한 서버 인증 처리 |
/mcp에서 볼 수 있는 것
/mcp 실행 시
┌──────────────────────────────────────────┐
│ MCP Servers │
│ │
│ ✅ context7 (stdio) │
│ Tools: resolve-library-id, query-docs │
│ │
│ ✅ slack (http) │
│ Tools: slack_send_message, │
│ slack_read_channel, ... │
│ │
│ ❌ notion (http) - 인증 필요 │
│ → "인증" 선택하여 로그인 │
└──────────────────────────────────────────┘MCP 도구의 이름 규칙
MCP 도구는 mcp__서버이름__도구이름 형태로 불린다:
| 서버 | 도구 | 전체 이름 |
|---|---|---|
| Slack | slack_read_channel | mcp__claude_ai_Slack__slack_read_channel |
| context7 | query-docs | mcp__context7__query-docs |
이름이 길지만 직접 외울 필요 없다. Claude에게 "Slack 메시지 읽어줘"라고 하면 알아서 올바른 도구를 호출한다.
claude.ai에서 MCP 연결하기 (가장 쉬운 방법)
터미널에서 claude mcp add 명령어 외에, 웹 브라우저에서 클릭 몇 번으로 MCP를 연결하는 방법이 있다:
1. https://claude.ai/settings/connectors 접속
2. 연결하고 싶은 서비스 선택 (Slack, Notion 등)
3. 로그인 후 연결 승인
4. Claude Code에서 /mcp → "claude.ai" 섹션에 자동 등록!/mcp 실행 시 (Connectors로 연결한 경우)
┌──────────────────────────────────────────┐
│ MCP Servers │
│ │
│ 📌 claude.ai │
│ ✅ Slack │
│ Tools: slack_send_message, │
│ slack_read_channel, ... │
│ │
│ 📌 local │
│ ✅ context7 (stdio) │
│ Tools: resolve-library-id, query-docs │
└──────────────────────────────────────────┘Slack을 처음 연결한다면 이 방법이 가장 쉽다. 터미널 명령어 없이 웹에서 로그인만 하면 된다.
OAuth 인증이 필요한 서버
Notion, GitHub, Sentry 같은 서비스는 로그인이 필요하다:
1. /mcp 실행
2. 인증이 필요한 서버 옆의 "인증" 선택
3. 브라우저가 열리면 로그인
4. 인증 완료 → 서버 연결됨인증 토큰은 자동 저장되고 자동 갱신된다. 한 번만 하면 된다.
EXECUTE
3단계로 /mcp 명령어를 체험해보자:
1단계: /mcp 실행
Claude Code에서 아래를 입력한다:
/mcp연결된 서버 목록이 나온다. 각 서버의 상태(연결/오류)와 제공하는 도구를 확인하자.
2단계: 도구 목록 확인
/mcp 화면에서 각 서버를 열어보면 그 서버가 제공하는 도구(Tools) 목록이 나온다. 어떤 도구가 있는지 살펴보자.
3단계: 도구 실제 사용
연결된 서버의 도구를 Claude에게 사용해달라고 요청해본다:
Context7이 있다면:
context7으로 React의 useEffect 사용법을 검색해줘Slack이 있다면:
Slack에서 가장 최근 메시지 5개를 보여줘Fetch가 있다면:
https://news.ycombinator.com 에서 오늘의 인기 글 3개를 가져와줘QUIZ
AskUserQuestion({
"questions": [{
"question": "/mcp 명령어의 주요 역할은?",
"header": "Quiz 2",
"options": [
{"label": "연결된 MCP 서버 상태와 도구 목록 확인", "description": "서버 연결 상태, 제공 도구, OAuth 인증까지"},
{"label": "새 MCP 서버를 설치하는 명령어", "description": "설치는 claude mcp add로 함"},
{"label": "MCP 서버를 삭제하는 명령어", "description": "삭제는 claude mcp remove로 함"}
],
"multiSelect": false
}]
})정답: 1번. 피드백: "맞습니다! /mcp = 현황 파악. 설치는 claude mcp add, 삭제는 claude mcp remove입니다. /mcp는 '지금 뭐가 연결되어 있지?' 할 때 씁니다."
Block 3: 인기 MCP 서버 탐색 및 설치
Phase A 시작 시 반드시 아래 형태로 출력한다:
```
📖 공식 문서: https://code.claude.com/docs/ko/mcp#popular-mcp-servers
📖 MCP 서버 목록: https://github.com/modelcontextprotocol/servers/blob/main/README.md
```
EXPLAIN
MCP 서버는 어디서 찾나?
| 출처 | URL | 특징 |
|---|---|---|
| Claude Code 공식 문서 | https://code.claude.com/docs/ko/mcp | Claude Code와 호환 확인된 서버 |
| MCP 서버 GitHub | https://github.com/modelcontextprotocol/servers | 전체 목록 (레퍼런스 + 서드파티) |
| MCP Registry | https://registry.modelcontextprotocol.io | 최신 서버 검색 |
비개발자에게 추천하는 인기 서버
커뮤니케이션
| 서버 | 할 수 있는 것 | 추가 명령어 |
|---|---|---|
| Slack | 메시지 읽기/보내기, 채널 검색 | claude mcp add --transport http slack https://api.slack.com/mcp |
| Gmail | 이메일 읽기/보내기, 검색 | 별도 설정 필요 (Google API) |
생산성
| 서버 | 할 수 있는 것 | 추가 명령어 |
|---|---|---|
| Notion | 페이지 읽기/쓰기, DB 쿼리 | claude mcp add --transport http notion https://mcp.notion.com/mcp |
| Google Calendar | 일정 조회/생성 | 별도 설정 필요 (Google API) |
| Linear | 이슈 관리, 프로젝트 추적 | claude mcp add --transport http linear https://mcp.linear.app/sse |
개발
| 서버 | 할 수 있는 것 | 추가 명령어 |
|---|---|---|
| GitHub | PR 리뷰, 이슈 관리 | claude mcp add --transport http github https://api.githubcopilot.com/mcp/ |
| Sentry | 에러 모니터링, 디버깅 | claude mcp add --transport http sentry https://mcp.sentry.dev/mcp |
| Context7 | 라이브러리 문서 검색 | claude mcp add --transport stdio context7 -- npx -y @upstash/context7-mcp@latest |
데이터
| 서버 | 할 수 있는 것 | 추가 명령어 |
|---|---|---|
| Fetch | 웹페이지 내용 가져오기 | claude mcp add --transport stdio fetch -- npx -y @anthropic-ai/mcp-fetch@latest |
| Filesystem | 로컬 파일 읽기/쓰기 | claude mcp add --transport stdio fs -- npx -y @modelcontextprotocol/server-filesystem /path |
| Memory | 지식 그래프 기반 기억 | claude mcp add --transport stdio memory -- npx -y @modelcontextprotocol/server-memory |
서버 선택 기준
내가 매일 쓰는 도구가 뭐지?
│
├─ Slack 많이 쓴다 → Slack MCP
├─ Notion에 정보 정리 → Notion MCP
├─ 이메일 관리 → Gmail MCP
├─ 코딩한다 → GitHub + Sentry MCP
└─ 웹 검색/리서치 → Fetch MCP한 번에 다 설치하지 말고, 가장 자주 쓰는 도구 1~2개부터 시작하자.
MCP의 한계 — 왜 Skill을 직접 만들어야 하나?
MCP 서버는 남이 만들어둔 범용 도구다. 설치만 하면 바로 쓸 수 있어서 편하지만, 한계가 있다:
MCP 서버 (남이 만든 것) 나만의 Skill (직접 만든 것)
├─ 설치 즉시 사용 가능 ├─ 내 워크플로우에 딱 맞게 설계
├─ 범용적 기능 제공 ├─ 필요한 기능만 조합
├─ 커스텀이 어려움 ⚠️ ├─ 자유롭게 수정 가능
└─ 모든 기능이 다 필요한 건 아님 └─ 진짜 효율적인 자동화예를 들어, Slack MCP를 설치하면 메시지를 읽고 보낼 수 있다. 하지만 "매일 아침 3개 채널의 중요 메시지를 요약해서 Notion에 정리해줘" 같은 나만의 워크플로우는 MCP만으로는 만들 수 없다.
결론: MCP로 시작하되, 진짜 효과적인 워크플로우를 원한다면 직접 Skill로 만들자.
Day 2에서 이걸 직접 해본다!
EXECUTE
3단계로 인기 서버를 탐색하고 설치해보자:
1단계: 공식 문서에서 인기 서버 확인
Claude에게 물어보자:
Claude Code 공식 문서에서 추천하는 인기 MCP 서버 목록을 보여줘. 각각 뭘 할 수 있는지도 알려줘2단계: 내게 필요한 서버 선택 및 설치
위 목록에서 하나를 골라 설치한다. 추천 순서:
1. 업무에서 가장 많이 쓰는 도구 2. 모르겠으면 Notion 또는 Fetch부터
설치 후 Claude Code를 새 세션으로 재시작한다 (기존 세션 종료 → claude 다시 실행).
3단계: 설치한 서버 도구 사용해보기
새 세션에서 /mcp로 서버가 연결되었는지 확인한 후, Claude에게 도구를 사용해달라고 요청한다.
방금 설치한 MCP 서버의 도구를 사용해서 뭔가 해봐QUIZ
AskUserQuestion({
"questions": [{
"question": "MCP 서버를 선택할 때 가장 좋은 기준은?",
"header": "Quiz 3",
"options": [
{"label": "내가 매일 쓰는 도구부터 1~2개", "description": "실제 업무에서 바로 활용할 수 있는 것"},
{"label": "인기 순위 1위부터 전부 설치", "description": "안 쓰는 서버는 리소스 낭비"},
{"label": "가장 기술적으로 복잡한 것", "description": "복잡할수록 좋은 게 아님"}
],
"multiSelect": false
}]
})정답: 1번. 피드백: "맞습니다! 매일 쓰는 도구부터 연결하면 바로 체감할 수 있습니다. 나중에 필요할 때 하나씩 추가하면 됩니다."
Block 4: /plugin으로 MCP 확장
Phase A 시작 시 반드시 아래 형태로 출력한다:
```
📖 공식 문서: https://code.claude.com/docs/ko/plugins
📖 플러그인 마켓: https://code.claude.com/docs/ko/discover-plugins
```
EXPLAIN
Plugin과 MCP의 관계
Day 1에서 배웠듯, Plugin = Skill + MCP + Hook + Agent를 묶은 패키지다.
Plugin 안에 MCP가 포함될 수 있다
┌─────────────────────────────────┐
│ My Plugin │
│ │
│ ┌─────────┐ ┌──────────────┐ │
│ │ Skills │ │ MCP Servers │ │
│ └─────────┘ └──────────────┘ │
│ ┌─────────┐ ┌──────────────┐ │
│ │ Hooks │ │ Agents │ │
│ └─────────┘ └──────────────┘ │
└─────────────────────────────────┘Plugin을 설치하면 그 안에 포함된 MCP 서버가 자동으로 연결된다. 따로 claude mcp add를 할 필요가 없다.
/plugin 명령어
| 명령어 | 동작 |
|---|---|
/plugin | 플러그인 관리 메뉴 열기 |
/plugin marketplace add [URL] | 마켓플레이스 등록 |
/plugin install [이름] | 플러그인 설치 |
Plugin이 MCP보다 좋은 점
| 항목 | MCP만 | Plugin + MCP |
|---|---|---|
| 설치 | claude mcp add ... 직접 입력 | /plugin install 한 줄 |
| 팀 공유 | 각자 설정 | 플러그인 하나로 동일 환경 |
| 추가 기능 | MCP 도구만 | Skill + Hook + Agent까지 |
| 업데이트 | 수동 | 플러그인 업데이트로 자동 |
Official Plugin vs Community Plugin
Official Plugins Community Plugins
├─ Anthropic이 검증 ├─ 커뮤니티가 만든 것
├─ /plugin에서 바로 설치 ├─ marketplace 등록 후 설치
└─ 안정성 보장 └─ 다양한 기능
/plugin /plugin marketplace add [URL]
→ 목록에서 선택 → /plugin install [이름]EXECUTE
3단계로 Plugin을 통한 MCP 확장을 체험해보자:
1단계: /plugin으로 공식 플러그인 탐색
Claude Code에서 아래를 입력한다:
/plugin설치 가능한 공식 플러그인 목록이 나온다. 각 플러그인의 설명을 읽어보고 마음에 드는 것을 골라 설치해보자.
2단계: 커뮤니티 마켓플레이스 등록
Anthropic 공식 외에도 커뮤니티가 만든 플러그인이 있다. 마켓플레이스를 등록해보자:
/plugin marketplace add obra/superpowers-marketplace등록 후 플러그인을 설치한다:
/plugin install superpowers@superpowers-marketplacesuperpowers는 TDD, 디버깅, 코드리뷰 등 개발 워크플로우를 강화하는 플러그인이다.
3단계: 설치된 플러그인의 MCP 확인
플러그인을 설치한 후 /mcp를 실행해서 플러그인이 자동으로 추가한 MCP 서버가 있는지 확인한다:
/mcp플러그인에 MCP 서버가 포함되어 있으면 자동으로 목록에 나타난다.
QUIZ
AskUserQuestion({
"questions": [{
"question": "Plugin에 MCP 서버가 포함되어 있으면?",
"header": "Quiz 4",
"options": [
{"label": "설치하면 MCP 서버가 자동으로 연결된다", "description": "claude mcp add 없이 자동 설정"},
{"label": "별도로 claude mcp add를 해야 한다", "description": "Plugin이 자동 처리"},
{"label": "MCP와 Plugin은 관련 없다", "description": "Plugin은 MCP를 포함할 수 있음"}
],
"multiSelect": false
}]
})정답: 1번. 피드백: "정확합니다! Plugin의 큰 장점이 바로 이겁니다. 복잡한 설정 없이 설치 한 줄이면 MCP 서버까지 자동 연결됩니다."
Block 5: Context Sync 개념 + 스켈레톤 생성
Phase A 시작 시 반드시 아래 형태로 출력한다:
```
📖 공식 문서: https://code.claude.com/docs/ko/sub-agents
```
EXPLAIN
Context Sync란?
매일 아침 출근하면 이런 일을 한다:
1. Slack 열어서 밤새 온 메시지 확인 2. Gmail 열어서 안 읽은 이메일 확인 3. 캘린더 열어서 오늘 일정 확인 4. Notion 열어서 내 태스크 확인 5. Linear 열어서 이슈 확인
5개 앱을 돌아다니며 30분. 매일 반복. 이것이 컨텍스트 스위칭이다.
Context Sync는 이 과정을 자동화한다. Claude Code가 여러 도구에서 정보를 모아서 하나의 문서로 정리해준다. 한 번 만들어두면 "싱크해줘" 한 마디로 끝난다.
평소 Context Sync 이후
───────────── ──────────────────
Slack 열기 "싱크해줘" (한 마디)
Gmail 열기 │
Calendar 열기 ──▶ Claude가 알아서 수집
Notion 열기 │
Linear 열기 하나의 문서로 정리!
= 30분 소요 = 1분 소요Day 1에서 배운 것과의 연결
Day 1 Block 3-2에서 스킬(Skill)을 배웠다. "반복하는 업무를 한 번 저장하면 다음부터 한 줄로 실행하는 업무 레시피." 오늘은 이 스킬을 직접 만든다. 그것도 여러 도구를 연결하는 실전 스킬을.
오늘 만들 스킬: 4개 도구 × 4가지 연결 방법
오늘은 4개 도구를 각각 다른 방법으로 연결하면서 스킬을 완성한다. 블록마다 하나의 도구를 연결하고, 스킬 파일에 해당 소스를 채워넣는 점진적 빌드 방식이다.
| Block | 연결 방법 | 도구 | 핵심 배움 |
|---|---|---|---|
| 6 | claude.ai Connector | Slack | 가장 쉬운 연결. 클릭 몇 번이면 끝 |
| 7 | claude mcp add 명령어 | Notion | CLI로 MCP 서버 직접 추가 |
| 8 | Official Plugin (/plugin) | Linear | Plugin 설치 = MCP 자동 등록 |
| 9 | 커뮤니티 Plugin (구조 분석) | Plugin의 내부 구조까지 이해 |
4가지 방법을 다 배우면, 앞으로 어떤 도구든 상황에 맞는 방법으로 연결할 수 있다.
Explore 에이전트
스킬을 만들기 전에, 프로젝트의 현재 상태를 먼저 파악해야 한다. Explore 에이전트는 프로젝트의 폴더와 파일을 빠르게 탐색하는 전문 subagent다.
| 구분 | 일반 Subagent | Explore 에이전트 |
|---|---|---|
| 역할 | 다양한 작업 수행 | 파일/폴더 탐색 전문 |
| 권한 | 파일 읽기 + 쓰기 | 읽기 전용 (안전함) |
| 용도 | 분석, 작성, 실행 등 | 프로젝트 구조 파악 |
요리를 시작하기 전에 냉장고를 여는 것과 같다. 뭐가 있는지 먼저 파악해야 빠진 재료를 알 수 있다.
스킬은 이렇게 만들어진다
Block 5 (지금): [STUB] [STUB] [STUB] [STUB] ← 빈 골격 생성
Block 6: [Slack] [STUB] [STUB] [STUB] ← 소스 1 채움
Block 7: [Slack] [Notion] [STUB] [STUB] ← 소스 2 채움
Block 8: [Slack] [Notion] [Linear] [STUB] ← 소스 3 채움
Block 9: [Slack] [Notion] [Linear] [Google] ← 소스 4 채움
Block 10: [완성!] 병렬 수집 실행 → 결과 확인EXECUTE
Step 1: Explore 에이전트로 프로젝트 구조 파악
Claude가 Explore 에이전트를 호출하여 프로젝트 구조를 파악한다.
아래는 Claude가 자동으로 실행하는 코드입니다. 여러분이 직접 입력할 필요 없습니다.
Claude가 수행:
Agent(
description="프로젝트 구조 탐색",
prompt="프로젝트 루트에서 다음을 확인하라:
1. 전체 폴더 구조 (최대 2단계)
2. .claude/ 디렉토리 내용
3. .mcp.json 존재 여부와 내용
4. .env 파일 존재 여부
5. 기존 스킬이 있다면 목록",
subagent_type="Explore"
)탐색 결과를 사용자에게 공유한다:
- 이미 설정된 MCP 서버가 있는지
- API 키나 환경변수가 존재하는지
- 기존 스킬이 있는지
Step 2: 스켈레톤 스킬 파일 생성
templates/context-sync.md를 읽고, 사용자의 프로젝트에 .claude/skills/my-context-sync/SKILL.md를 생성한다.
생성 규칙: 1. 템플릿을 그대로 복사한다 (4개 소스의 STUB 포함) 2. Explore 결과를 바탕으로 frontmatter의 description을 프로젝트에 맞게 수정한다 3. 탐색에서 발견한 기존 설정이 있으면 해당 소스의 코멘트에 메모한다
Step 3: 생성 결과 확인
생성된 파일의 전체 구조를 보여준다:
.claude/skills/my-context-sync/SKILL.md 생성 완료!
구조:
📌 소스 1: Slack [STUB - Block 6에서 Connector로 연결]
📌 소스 2: Notion [STUB - Block 7에서 claude mcp add로 연결]
📌 소스 3: Linear [STUB - Block 8에서 /plugin install로 연결]
📌 소스 4: Google [STUB - Block 9에서 커뮤니티 Plugin으로 연결]
📌 실행 흐름 [STUB - Block 10에서 완성]
📌 출력 포맷 [STUB - Block 10에서 완성]
다음 블록(Block 6)부터 STUB을 하나씩 채워갑니다!지금은 빈 골격만 만든 것이다. Block 6부터 본격적으로 도구를 연결하고 소스를 채운다.
QUIZ
AskUserQuestion({
"questions": [{
"question": "Context Sync 스킬이 하는 일을 한 문장으로 말하면?",
"header": "Quiz Block 5",
"options": [
{"label": "Claude Code를 설치한다", "description": "설치는 Day 1에서 이미 완료"},
{"label": "여러 도구에서 정보를 모아 하나의 문서로 정리한다", "description": "Slack, Notion, Linear, Google에서 수집 → 통합"},
{"label": "Slack 메시지만 정리한다", "description": "Slack은 여러 소스 중 하나일 뿐"}
],
"multiSelect": false
}]
})정답: 2번. Context Sync 스킬은 여러 도구에서 정보를 모아 하나의 문서로 정리하는 스킬이다. 오늘은 4개 도구를 각각 다른 방법으로 연결하면서 이 스킬을 점진적으로 완성한다.
Block 6: Connector → Slack
Phase A 시작 시 반드시 아래 형태로 출력한다:
```
📖 참조: https://claude.ai/settings/connectors
```
EXPLAIN
첫 번째 연결 방법: Connector
도구를 Claude에 연결하는 가장 쉬운 방법이다. 클릭 몇 번이면 끝난다.
스마트폰에서 "Google로 로그인" 버튼 눌러본 적 있는가? Connector도 똑같다. 웹 브라우저에서 해당 서비스에 로그인만 하면 자동으로 연결된다.
Connector 연결 과정:
① https://claude.ai/settings/connectors 접속
② 연결하고 싶은 서비스 선택
③ 해당 서비스에 로그인
④ "허용" 클릭
⑤ 끝! Claude Code에서 바로 사용 가능Connector의 장점과 한계
| 장점 | 한계 |
|---|---|
| API 키가 필요 없다 | 지원하는 서비스가 정해져 있다 |
| 설정 파일을 건드릴 필요 없다 | 세밀한 설정이 어렵다 |
| 브라우저에서 클릭만 하면 된다 | 클라우드 기반이라 로컬 도구는 불가 |
| 연결 해제도 같은 페이지에서 클릭 한 번 |
/mcp에서 어떻게 보이는가?
Connector로 연결하면 /mcp 명령을 입력했을 때 "claude.ai" 섹션에 표시된다:
/mcp
→ claude.ai:
→ slack: connected (tools: 11)
→ notion: connected (tools: 8)뒤에서 배울 claude mcp add로 연결하면 "local" 섹션에 표시된다. 위치가 다른 것뿐, 사용법은 같다.오늘의 도구: Slack
Slack은 Connector를 지원하는 대표적인 도구다. 이번 블록에서 Slack을 Connector로 연결하고, 스킬의 소스 1을 채운다.
Plan B: Slack이 없다면?
Slack을 사용하지 않는다면 이 블록을 skip하고 Block 7로 이동할 수 있다. 소스 1은 비워둔 채 다음 도구부터 연결하면 된다.
EXECUTE
Step 1: Slack 사용 여부 확인
AskUserQuestion({
"questions": [{
"question": "Slack을 사용하고 계신가요?\n\n⚠️ 회사 Slack은 관리자 정책상 외부 앱 연결이 차단될 수 있습니다.",
"header": "Slack 확인",
"options": [
{"label": "네, Slack 연결합니다", "description": "Connector로 Slack을 연결합니다"},
{"label": "회사 계정이라 안 될 것 같아요", "description": "개인 Slack이나 AI Native Camp Slack으로 연결합니다"},
{"label": "Slack 안 씁니다, skip할게요", "description": "이 블록을 건너뛰고 Block 7로 이동합니다"}
],
"multiSelect": false
}]
})회사 계정 제한 시: 개인 Slack workspace나 AI Native Camp Slack으로 연결하면 된다. Connector 연결 방식 자체를 체험하는 것이 이 블록의 핵심이다.
Step 2: Connector로 Slack 연결
아래 과정을 안내한다:
① 브라우저에서 https://claude.ai/settings/connectors 에 접속하세요
② "Slack"을 찾아서 클릭하세요
③ Slack 워크스페이스에 로그인하세요
④ "허용(Allow)" 버튼을 클릭하세요
⑤ 완료!Step 3: 연결 확인 (/mcp)
터미널에서 연결 상태를 확인한다:
/mcp 입력
확인할 것:
→ claude.ai 섹션에 "slack: connected" 가 보이는지
→ tools 숫자가 표시되는지 (예: tools: 11)Step 4: 연결 테스트
실제로 Slack 도구가 작동하는지 간단히 테스트한다:
Claude에게 요청: "Slack 채널 목록 보여줘"
기대 결과:
- Slack 워크스페이스의 채널 목록이 출력됨
- 또는 특정 채널의 최근 메시지가 출력됨테스트에서 에러가 발생하면 Connectors 페이지에서 연결을 해제했다가 다시 연결해본다.
Step 5: 스킬 소스 1 채우기
테스트가 성공하면, .claude/skills/my-context-sync/SKILL.md의 소스 1: Slack 섹션을 채운다.
STUB을 실제 내용으로 교체:
### 소스 1: Slack
| 항목 | 값 |
|------|-----|
| 연결 방법 | Connector (claude.ai/settings/connectors) |
| MCP 도구 | `mcp__claude_ai_Slack__slack_read_channel` |
| 수집 범위 | 최근 7일 |
수집할 채널 목록:
(테스트에서 확인한 실제 채널명으로 채운다)
수집 방법:
각 채널에 대해 mcp__claude_ai_Slack__slack_read_channel 호출.
mcp__claude_ai_Slack__slack_read_channel(channel="general", limit=50)
추출할 정보:
- 중요 공지사항
- 의사결정 사항 ("확정", "결정", "합의" 키워드)
- 나에게 멘션된 메시지
- 답장이 필요한 질문스킬 파일의 진행 상황:
```
소스 1: Slack ✅ 채움!
소스 2: Notion [STUB]
소스 3: Linear [STUB]
소스 4: Google [STUB]
```
QUIZ
AskUserQuestion({
"questions": [
{
"question": "Connector로 도구를 연결하면 /mcp에서 어느 섹션에 표시되나요?",
"header": "Quiz 6-1",
"options": [
{"label": "local 섹션", "description": "local은 claude mcp add로 연결한 것"},
{"label": "plugin 섹션", "description": "plugin은 /plugin으로 설치한 것"},
{"label": "claude.ai 섹션", "description": "Connector는 claude.ai 클라우드를 통해 연결"}
],
"multiSelect": false
},
{
"question": "Connector의 가장 큰 장점은?",
"header": "Quiz 6-2",
"options": [
{"label": "모든 도구를 연결할 수 있다", "description": "Connector가 지원하는 서비스만 가능"},
{"label": "가장 빠르다", "description": "속도보다는 편의성이 핵심 장점"},
{"label": "API 키 없이 브라우저 로그인만으로 연결된다", "description": "클릭 몇 번이면 끝나는 가장 쉬운 방법"}
],
"multiSelect": false
}
]
})정답: Quiz 6-1은 3번, Quiz 6-2는 3번.
- Connector로 연결하면
/mcp의 claude.ai 섹션에 표시된다. 뒤에서 배울claude mcp add는 local 섹션에 표시된다. - Connector의 최대 장점은 API 키 없이 브라우저 로그인만으로 연결된다는 것이다. 비개발자에게 가장 친절한 방법이다.
Block 7: claude mcp add → Notion
Phase A 시작 시 반드시 아래 형태로 출력한다:
```
📖 공식 문서: https://code.claude.com/docs/ko/mcp
📖 참조: https://mcp.notion.com
```
EXPLAIN
두 번째 연결 방법: claude mcp add
Block 6에서는 Connector로 연결했다. 클릭 몇 번이면 끝나는 가장 쉬운 방법이었다.
하지만 Connector에 원하는 서비스가 없을 수도 있다. 그럴 때 쓰는 것이 `claude mcp add` 명령어다. 터미널에 한 줄 입력하면 MCP 서버가 등록된다.
Connector: 브라우저에서 클릭 → 자동 연결 (블루투스 자동 페어링)
claude mcp add: 터미널에 명령어 입력 → 수동 연결 (와이파이 비밀번호 입력)Connector vs claude mcp add 비교
| 비교 | Connector (Block 6) | claude mcp add (이번 블록) |
|---|---|---|
| 비유 | 블루투스 자동 연결 | 와이파이 비밀번호 입력 |
| 난이도 | ★☆☆☆ (클릭만) | ★★☆☆ (명령어 한 줄) |
/mcp 위치 | claude.ai 섹션 | local 섹션 |
| 설정 파일 | 필요 없음 | .mcp.json 자동 생성 |
| 지원 범위 | 정해진 서비스만 | HTTP MCP 서버가 있는 모든 도구 |
.mcp.json이란?
claude mcp add 명령어를 실행하면 프로젝트 루트에 .mcp.json 파일이 자동으로 만들어진다.
내 프로젝트/
├── .mcp.json <-- MCP 서버 설정 파일 (여기!)
├── .claude/
│ └── skills/
│ └── my-context-sync/
└── ...파일 안에는 "어떤 서버를, 어떻게 연결할지"가 적혀 있다:
{
"mcpServers": {
"notion": {
"type": "http",
"url": "https://mcp.notion.com/mcp"
}
}
}대부분 Claude가 알아서 만들어주므로 직접 수정할 일은 거의 없다. 하지만 구조를 알아두면 나중에 Plugin을 이해할 때 도움이 된다.
오늘의 도구: Notion
Notion은 공식 HTTP MCP 서버(https://mcp.notion.com/mcp)를 제공한다. claude mcp add 한 줄이면 연결된다.
Plan B: Notion이 없다면?
Notion을 사용하지 않는다면, Claude가 대체 MCP 서버를 검색해준다. "다른 도구를 연결하고 싶어요"라고 말하면 Claude가 scripts/mcp_servers.py를 실행하여 사용 가능한 MCP 서버를 찾아준다.
검색 결과에서 적합한 서버를 찾아 claude mcp add로 등록하면 된다.
⚠️ 보안 안내: MCP 서버에 연결하면 해당 서비스의 데이터에 Claude가 접근할 수 있다. 회사 데이터가 포함된 서비스는 개인 workspace나 테스트 환경으로 연결하는 것을 권장한다.
EXECUTE
Step 1: Notion 사용 여부 확인
AskUserQuestion({
"questions": [{
"question": "Notion을 사용하고 계신가요?",
"header": "Notion 확인",
"options": [
{"label": "네, Notion 사용합니다", "description": "Notion MCP 서버로 연결합니다"},
{"label": "아니요, 다른 도구로 할게요", "description": "mcp_servers.py로 대체 서버를 검색합니다"}
],
"multiSelect": false
}]
})Step 2: MCP 서버 등록
Notion을 사용하는 경우:
Claude가 아래 명령어를 실행한다:
claude mcp add --transport http notion https://mcp.notion.com/mcp명령어 해부:
claude mcp add ← "MCP 서버를 추가해줘"
--transport http ← "클라우드 웹 서버야" (로컬이 아님)
notion ← "이름은 notion으로 해줘"
https://mcp.notion.com/mcp ← "이 주소로 연결해줘"다른 도구를 선택한 경우:
Claude가 scripts/mcp_servers.py를 실행하여 대체 MCP 서버를 검색한다. 사용자가 원하는 도구명을 말하면 Claude가 알아서 검색하고, 적합한 서버를 찾아 claude mcp add로 등록한다.
⚠️ 보안 안내: 연결 시 브라우저에서 해당 서비스의 인증 페이지가 열릴 수 있다. 회사 데이터가 있는 서비스는 개인 workspace나 테스트 환경 사용을 권장한다.
Step 3: 연결 확인 (/mcp)
/mcp 입력
확인할 것:
→ local 섹션에 "notion" 이 보이는지
→ connected 상태인지
→ 도구(tools) 숫자가 표시되는지
⚠️ Block 6의 Connector는 "claude.ai" 섹션에 있었다.
이번에는 "local" 섹션에 있는 것을 확인하자!Notion 연결 시 브라우저에서 Notion 인증 페이지가 열릴 수 있다. 로그인하고 "허용"을 클릭하면 된다.
Step 4: 연결 테스트
Claude에게 요청: "Notion에서 최근 수정된 페이지 보여줘"
기대 결과:
- Notion workspace의 페이지 목록이 출력됨
- 또는 특정 데이터베이스의 항목이 출력됨Step 5: 스킬 소스 2 채우기
.claude/skills/my-context-sync/SKILL.md의 소스 2: Notion 섹션을 채운다.
### 소스 2: Notion
| 항목 | 값 |
|------|-----|
| 연결 방법 | `claude mcp add --transport http` |
| MCP 서버 | `https://mcp.notion.com/mcp` |
| 수집 범위 | 지정된 데이터베이스 |
databases:
- name: "{사용자 DB명}"
id: "{실제 DB ID}"
수집 방법:
Notion MCP 서버의 도구를 사용하여 데이터베이스를 조회한다.
mcp__notion__search(query="")
mcp__notion__query_database(database_id="{id}")
추출할 정보:
- 진행 중인 태스크
- 기한이 임박한 항목
- 최근 업데이트된 페이지스킬 파일의 진행 상황:
```
소스 1: Slack ✅ 채움!
소스 2: Notion ✅ 채움!
소스 3: Linear [STUB]
소스 4: Google [STUB]
```
QUIZ
AskUserQuestion({
"questions": [
{
"question": "`claude mcp add --transport http` 에서 `--transport http`의 의미는?",
"header": "Quiz 7-1",
"options": [
{"label": "보안 연결이라는 뜻", "description": "보안과는 다른 개념"},
{"label": "로컬 컴퓨터에서 실행한다는 뜻", "description": "로컬 실행은 stdio 방식"},
{"label": "클라우드 웹 서버에 연결한다는 뜻", "description": "HTTP = 인터넷을 통한 원격 연결"}
],
"multiSelect": false
},
{
"question": "`claude mcp add` 명령어를 실행하면 어떤 파일이 자동으로 생성되나요?",
"header": "Quiz 7-2",
"options": [
{"label": "CLAUDE.md", "description": "CLAUDE.md는 Claude의 지시사항 파일"},
{"label": ".mcp.json", "description": "프로젝트 루트에 MCP 서버 설정이 저장됨"},
{"label": "SKILL.md", "description": "SKILL.md는 스킬 정의 파일"}
],
"multiSelect": false
}
]
})정답: Quiz 7-1은 3번, Quiz 7-2는 2번.
--transport http는 클라우드 웹 서버에 연결한다는 뜻이다. 인터넷을 통해 원격 MCP 서버에 접속한다. (로컬 실행은stdio방식)claude mcp add명령어를 실행하면 프로젝트 루트에 `.mcp.json` 파일이 자동으로 생성/업데이트된다. 어떤 서버를 어떻게 연결할지 적어놓는 설정 파일이다.
Block 8: Official Plugin → Linear
Phase A 시작 시 반드시 아래 형태로 출력한다:
```
📖 참조: https://github.com/anthropics/claude-plugins-official/tree/main/external_plugins
```
EXPLAIN
세 번째 연결 방법: Official Plugin (/plugin)
Block 6에서 Connector(클릭), Block 7에서 claude mcp add(명령어 한 줄)를 배웠다. 이번에는 Plugin이다.
Day 1 Block 3-5에서 Plugin을 잠깐 언급했다: "Skill + MCP + Hook + Agent를 묶은 패키지." 이번에 실제로 설치해본다.
Plugin이 특별한 이유
Plugin을 설치하면 MCP 서버가 자동으로 등록된다. claude mcp add를 별도로 실행할 필요가 없다.
claude mcp add (Block 7): 명령어 실행 → MCP 서버 등록
/plugin install (이번 블록): 설치 한 줄 → MCP + 스킬 + 설정 전부 자동!비유하면:
Connector (Block 6) = 블루투스 이어폰 (페어링만 하면 끝)
claude mcp add (Block 7) = 와이파이 공유기 (비밀번호 입력)
Plugin (이번 블록) = 스마트홈 패키지 (조명+스피커+센서 한 번에 설치)3가지 연결 방법 비교 (여기까지 정리)
| 비교 | Connector | claude mcp add | Plugin |
|---|---|---|---|
| Block | 6 | 7 | 8 (지금) |
| 도구 | Slack | Notion | Linear |
| 비유 | 블루투스 | 와이파이 | 스마트홈 패키지 |
| 난이도 | ★☆☆☆ | ★★☆☆ | ★★★☆ |
| MCP 등록 | 자동 (cloud) | 수동 (명령어) | 자동 (패키지) |
| 설정 파일 | 없음 | .mcp.json | `.mcp.json` 자동 생성 |
| 추가 기능 | MCP만 | MCP만 | MCP + Skill + Hook + Agent |
/mcp 위치 | claude.ai 섹션 | local 섹션 | local 섹션 |
Plugin은 MCP만 연결하는 게 아니라, 스킬/훅/에이전트까지 한꺼번에 설치한다. 가장 많은 것을 한 번에 하는 방법이다.
오늘의 도구: Linear
Linear는 이슈 트래커다. 팀의 할 일(이슈)을 관리하는 도구로, 공식 Plugin이 제공된다.
Plan B: Linear가 없다면?
Linear를 사용하지 않는다면, 다른 공식 Plugin으로 같은 체험을 할 수 있다:
1. /plugin 명령어를 실행하면 설치 가능한 Plugin 목록이 나온다 2. 자신이 사용하는 도구의 Plugin이 있으면 그것을 설치한다 (예: GitHub, Jira 등) 3. 어떤 Plugin이든 "설치 → MCP 자동 등록" 과정은 동일하다 4. Plugin이 없으면 이 블록을 skip하고 Block 9로 이동할 수 있다
⚠️ 보안 안내: Plugin 설치 시 인증이 필요할 수 있다. 회사 계정이 제한될 경우 개인 계정이나 테스트 환경을 사용한다.
EXECUTE
Step 1: Linear 사용 여부 확인
AskUserQuestion({
"questions": [{
"question": "Linear (이슈 트래커)를 사용하고 계신가요?",
"header": "Linear 확인",
"options": [
{"label": "네, Linear 사용합니다", "description": "Linear Plugin을 설치합니다"},
{"label": "아니요, 다른 Plugin으로 할게요", "description": "/plugin에서 다른 공식 Plugin을 찾습니다"},
{"label": "Skip할게요", "description": "이 블록을 건너뛰고 Block 9로 이동합니다"}
],
"multiSelect": false
}]
})Linear가 없어도 괜찮습니다. 이 블록의 핵심은 "Plugin을 설치하면 MCP가 자동으로 등록된다"는 체험입니다. 다른 공식 Plugin으로도 같은 체험이 가능합니다.
Step 2: /plugin 명령어로 Plugin 찾기
터미널에서 /plugin을 실행한다:
/plugin
→ 설치 가능한 플러그인 목록이 표시됨
→ Linear (또는 선택한 다른 Plugin)을 찾는다Step 3: Plugin 설치
/plugin install linear설치가 완료되면 아래가 자동으로 처리된다:
- Plugin의
.mcp.json이 자동 활성화되어 Linear MCP 서버가 연결됨 - Linear 관련 스킬이 설치될 수 있음
- 필요한 설정이 자동으로 구성됨
⚠️ Plugin 설치 후 MCP 연결이 바로 안 보이면 Claude Code를 재시작해보세요.
Step 4: /mcp로 자동 등록 확인
/mcp 입력
확인할 것:
→ local 섹션에 "linear" 가 자동으로 추가되었는지
→ "claude mcp add를 안 했는데 MCP가 등록됐다!" ← 이것이 Plugin의 힘
⚠️ 비교해보자:
Block 6 (Connector): claude.ai 섹션 → slack
Block 7 (mcp add): local 섹션 → notion
Block 8 (Plugin): local 섹션 → linear (자동 등록!)이것이 Plugin의 핵심 편의성이다. Plugin 안에 MCP 설정이 포함되어 있어서, 설치만 하면 MCP 서버가 자동으로 활성화된다.
Step 5: 연결 테스트
Claude에게 요청: "Linear 이슈 목록 보여줘"
기대 결과:
- Linear workspace의 이슈 목록이 출력됨
- 나에게 할당된 이슈가 보임Linear 인증 화면이 나오면 로그인하고 "허용"을 클릭한다.
Step 6: 스킬 소스 3 채우기
.claude/skills/my-context-sync/SKILL.md의 소스 3: Linear 섹션을 채운다.
### 소스 3: Linear
| 항목 | 값 |
|------|-----|
| 연결 방법 | Official Plugin (`/plugin install linear`) |
| MCP 도구 | Linear Plugin이 등록한 MCP 도구 |
| 수집 범위 | 나에게 할당된 이슈 |
수집 방법:
Linear Plugin의 MCP 도구를 사용하여 이슈를 조회한다.
(도구명은 /mcp에서 확인한 것으로 교체)
추출할 정보:
- 진행 중인 이슈
- 이번 주 마감 이슈
- 최근 댓글/업데이트스킬 파일의 진행 상황:
```
소스 1: Slack ✅ 채움!
소스 2: Notion ✅ 채움!
소스 3: Linear ✅ 채움!
소스 4: Google [STUB]
```
QUIZ
AskUserQuestion({
"questions": [
{
"question": "Plugin을 설치하면 MCP 서버를 별도로 추가해야 하나요?",
"header": "Quiz 8-1",
"options": [
{"label": "네, claude mcp add를 따로 실행해야 합니다", "description": "Plugin의 장점은 자동 등록"},
{"label": "아니요, Plugin이 MCP를 자동으로 활성화합니다", "description": "/plugin install만 하면 MCP가 자동 연결"},
{"label": "MCP와 Plugin은 관계없습니다", "description": "Plugin은 MCP를 포함하는 패키지"}
],
"multiSelect": false
},
{
"question": "Plugin이 다른 연결 방법보다 편한 이유는?",
"header": "Quiz 8-2",
"options": [
{"label": "가장 빠르기 때문", "description": "속도보다는 '한 번에 다 되는' 편의성"},
{"label": "무료이기 때문", "description": "다른 방법도 무료"},
{"label": "MCP + 스킬 + 설정을 한꺼번에 설치하기 때문", "description": "스마트홈 패키지처럼 한 번에 모든 것이 설치됨"}
],
"multiSelect": false
}
]
})정답: Quiz 8-1은 2번, Quiz 8-2는 3번.
- Plugin을 설치하면 Plugin 안에 포함된 MCP 설정이 자동으로 활성화된다.
claude mcp add를 별도로 실행할 필요가 없다. 이것이 Plugin의 가장 큰 편의성이다. - Plugin이 편한 이유는 MCP + 스킬 + 설정을 한꺼번에 설치하기 때문이다. 스마트홈 패키지처럼 설치 한 줄이면 모든 것이 한 번에 구성된다.
Block 9: Plugin 구조 분석 → Google Calendar/Gmail
Phase A 시작 시 반드시 아래 형태로 출력한다:
```
📖 참조: https://github.com/team-attention/plugins-for-claude-natives
```
EXPLAIN
네 번째 연결 방법: 커뮤니티 Plugin (구조까지 이해하기)
Block 8에서 공식 Plugin을 /plugin install로 설치했다. 한 줄이면 MCP까지 자동 등록되는 편리함을 체험했다.
이번 블록에서는 한 걸음 더 나아간다:
"Plugin 속은 어떻게 생겼을까?"
Plugin을 쓸 줄 아는 사람과 만들 줄 아는 사람은 다르다. Plugin의 내부 구조를 이해하면, 나중에 나만의 Plugin도 만들 수 있다.
Plugin 디렉토리 구조
Plugin은 이런 파일들로 구성되어 있다:
my-plugin/
├── plugin.json ← "이 Plugin의 이력서" (루트에 위치)
├── skills/ ← 스킬 파일들 (루트에 위치)
│ └── my-skill/
│ └── SKILL.md
├── .mcp.json ← MCP 서버 자동 등록 설정 (루트에 위치)
├── settings.json ← Claude Code 설정 (루트에 위치)
└── hooks/ ← 자동 실행 트리거파일별 역할
| 파일 | 역할 | 비유 |
|---|---|---|
plugin.json | Plugin 정보 (이름, 설명, 버전) | 제품 상자의 라벨 |
skills/ | 이 Plugin이 가르치는 스킬 | 설명서 |
.mcp.json | MCP 서버 자동 등록 설정 | 전원 어댑터 (꽂으면 바로 연결) |
settings.json | Claude Code 설정 | 기본 세팅 값 |
hooks/ | 특정 시점에 자동 실행되는 스크립트 | 알람 설정 |
핵심: .mcp.json이 Plugin 루트에 있기 때문에 Plugin을 설치하면 MCP가 자동으로 활성화되는 것이다! Block 8에서 "claude mcp add 안 했는데!" 했던 이유가 바로 이 파일 덕분이다.커뮤니티 Plugin
공식 Plugin 외에 커뮤니티에서 만든 Plugin도 있다. 오늘은 team-attention/plugins-for-claude-natives에서 Google Calendar/Gmail Plugin을 설치한다.
이 Plugin은 비개발자를 위해 설계된 것으로:
- Google Calendar: 일정 조회, 생성, 수정
- Gmail: 이메일 조회, 발송, 검색
- 설치만 하면 MCP 서버가 자동 등록되어 바로 사용 가능
4가지 연결 방법 총정리
| # | 방법 | Block | 도구 | 난이도 | 핵심 |
|---|---|---|---|---|---|
| 1 | Connector | 6 | Slack | ★☆☆☆ | 브라우저 클릭 |
| 2 | claude mcp add | 7 | Notion | ★★☆☆ | CLI 명령어 |
| 3 | Official Plugin | 8 | Linear | ★★★☆ | 공식 패키지 |
| 4 | 커뮤니티 Plugin | 9 | ★★★★ | 구조 이해 + 설치 |
Plan B: Google 서비스가 없다면?
Google Calendar/Gmail을 사용하지 않는다면, Plugin의 구조 분석만 진행하고 소스 4를 비워둘 수 있다. 구조를 이해하는 것 자체가 이 블록의 핵심 배움이다.
EXECUTE
Step 1: 커뮤니티 Plugin Marketplace 추가
/plugin marketplace add team-attention/plugins-for-claude-natives이 명령어로 team-attention의 Plugin marketplace를 등록한다.
Step 2: 도구 선택
AskUserQuestion({
"questions": [{
"question": "Google Calendar과 Gmail 중 어떤 것을 연결할까요?",
"header": "Google 도구 선택",
"options": [
{"label": "Google Calendar", "description": "일정 조회/관리"},
{"label": "Gmail", "description": "이메일 조회/관리"},
{"label": "둘 다", "description": "Calendar + Gmail 모두 연결"},
{"label": "Skip", "description": "Plugin 구조 분석만 하고 넘어가기"}
],
"multiSelect": false
}]
})Step 3: Explore 에이전트로 Plugin 구조 탐색
설치 전에, Plugin의 내부 구조를 먼저 살펴본다:
아래는 Claude가 자동으로 실행하는 코드입니다. 여러분이 직접 입력할 필요 없습니다.
Claude가 수행:
Agent(
description="Plugin 구조 탐색",
prompt="team-attention/plugins-for-claude-natives 플러그인의 구조를 탐색하라:
1. plugin.json 내용
2. skills/ 디렉토리 구조
3. .mcp.json 내용 (MCP 자동 등록 설정)
4. 스킬 파일이 있다면 목록
5. hooks/ 디렉토리가 있다면 내용",
subagent_type="Explore"
)탐색 결과를 사용자에게 설명한다:
- "이 파일이 Plugin의 이력서(plugin.json)입니다"
- "이 파일(.mcp.json) 때문에 설치하면 MCP가 자동으로 활성화됩니다"
- "skills/ 폴더에 스킬이 들어있어서 설치 후 바로 사용할 수 있습니다"
⚠️ 보안 안내: Google 서비스 연결 시 Google 계정 인증이 필요하다. 회사 Google Workspace 계정은 관리자 정책에 따라 외부 앱 연결이 제한될 수 있으므로, 개인 Google 계정 사용을 권장한다.
Step 4: Plugin 설치
선택한 도구에 따라 설치한다:
# Google Calendar 선택 시
/plugin install google-calendar
# Gmail 선택 시
/plugin install gmail
# 둘 다 선택 시
/plugin install google-calendar
/plugin install gmailStep 5: /mcp 확인 + 테스트
/mcp 입력
확인할 것:
→ local 섹션에 google-calendar 또는 gmail이 추가되었는지
→ 연결 상태가 정상인지
테스트:
Calendar: "이번 주 일정 보여줘"
Gmail: "안 읽은 이메일 보여줘"Google 인증이 필요할 수 있다. 브라우저에서 Google 계정으로 로그인하고 "허용"을 클릭한다.
Step 6: 스킬 소스 4 채우기
.claude/skills/my-context-sync/SKILL.md의 소스 4: Google Calendar / Gmail 섹션을 채운다.
### 소스 4: Google Calendar / Gmail
| 항목 | 값 |
|------|-----|
| 연결 방법 | 커뮤니티 Plugin (team-attention/plugins-for-claude-natives) |
| MCP 도구 | Plugin이 등록한 Google Calendar/Gmail MCP 도구 |
| 수집 범위 | 오늘 ~ 7일 후 (Calendar) / 최근 7일 (Gmail) |
수집 방법:
Plugin의 MCP 도구를 사용하여 일정/이메일을 조회한다.
(도구명은 /mcp에서 확인한 것으로 교체)
추출할 정보:
- 오늘의 일정 + 이번 주 주요 미팅
- 안 읽은 이메일 요약
- 회신이 필요한 이메일
- 준비가 필요한 미팅스킬 파일의 진행 상황:
```
소스 1: Slack ✅ 채움!
소스 2: Notion ✅ 채움!
소스 3: Linear ✅ 채움!
소스 4: Google ✅ 채움!
실행 흐름 [STUB - Block 10에서 완성]
출력 포맷 [STUB - Block 10에서 완성]
```
QUIZ
AskUserQuestion({
"questions": [
{
"question": "Plugin 루트에 있는 `.mcp.json` 파일의 역할은?",
"header": "Quiz 9-1",
"options": [
{"label": "Plugin의 이름과 버전 정보", "description": "그건 plugin.json의 역할"},
{"label": "Claude Code의 보안 설정", "description": "보안 설정과는 다른 파일"},
{"label": "Plugin 설치 시 MCP 서버를 자동으로 활성화하는 설정", "description": "이 파일이 있어서 claude mcp add가 필요 없는 것"}
],
"multiSelect": false
},
{
"question": "4가지 연결 방법 중 가장 많은 것을 한 번에 설치하는 방법은?",
"header": "Quiz 9-2",
"options": [
{"label": "Connector", "description": "Connector는 MCP 연결만 제공"},
{"label": "Plugin (MCP + 스킬 + 설정 + 훅 포함)", "description": "패키지이므로 여러 구성요소를 한 번에 설치"},
{"label": "claude mcp add", "description": "mcp add는 MCP 서버 하나만 등록"}
],
"multiSelect": false
},
{
"question": "Plugin 구조를 이해하면 무엇이 가능해지나요?",
"header": "Quiz 9-3",
"options": [
{"label": "Claude Code를 더 빠르게 실행할 수 있다", "description": "속도와는 관계없음"},
{"label": "다른 사람의 Plugin을 삭제할 수 있다", "description": "삭제와는 관계없음"},
{"label": "나만의 Plugin을 만들 수 있다", "description": "구조를 알면 직접 제작 가능"}
],
"multiSelect": false
}
]
})정답: Quiz 9-1은 3번, Quiz 9-2는 2번, Quiz 9-3은 3번.
.mcp.json은 Plugin 루트에 위치하며, Plugin 설치 시 MCP 서버를 자동으로 활성화하는 설정 파일이다. Block 8에서 "claude mcp add 안 했는데!" 했던 비밀이 바로 이 파일이다.- Plugin은 MCP + 스킬 + 설정 + 훅을 한꺼번에 설치하므로, 4가지 방법 중 가장 많은 것을 한 번에 처리한다.
- Plugin 구조를 이해하면 나만의 Plugin을 만들 수 있다. "쓸 줄 아는 사람"에서 "만들 줄 아는 사람"으로 레벨업하는 것이다.
#!/usr/bin/env python3
# /// script
# requires-python = ">=3.12"
# dependencies = ["httpx"]
# ///
"""MCP 서버 검색 도구
GitHub의 MCP 서버 목록에서 원하는 서비스를 검색하고
.mcp.json 설정을 생성한다.
Usage:
python mcp_servers.py search <keyword> # 서버 검색
python mcp_servers.py generate <server> # .mcp.json 설정 생성
python mcp_servers.py download # README.md 최신 다운로드
"""
import json
import re
import sys
import time
from pathlib import Path
import httpx
README_URL = "https://raw.githubusercontent.com/modelcontextprotocol/servers/main/README.md"
CACHE_DIR = Path(__file__).parent / ".cache"
CACHE_FILE = CACHE_DIR / "mcp-servers-readme.md"
CACHE_META = CACHE_DIR / "cache-meta.json"
CACHE_TTL = 3600 # 1시간
# ─── 캐시 관리 ───────────────────────────────────────────────
def _is_cache_valid() -> bool:
"""캐시가 유효한지 확인 (1시간 이내)."""
if not CACHE_FILE.exists() or not CACHE_META.exists():
return False
try:
meta = json.loads(CACHE_META.read_text())
return (time.time() - meta.get("downloaded_at", 0)) < CACHE_TTL
except (json.JSONDecodeError, KeyError):
return False
def _save_cache(content: str) -> None:
"""README 내용을 로컬에 캐시."""
CACHE_DIR.mkdir(parents=True, exist_ok=True)
CACHE_FILE.write_text(content, encoding="utf-8")
CACHE_META.write_text(
json.dumps({"downloaded_at": time.time()}), encoding="utf-8"
)
def _load_cache() -> str | None:
"""캐시된 README를 읽는다."""
if CACHE_FILE.exists():
return CACHE_FILE.read_text(encoding="utf-8")
return None
# ─── 다운로드 ────────────────────────────────────────────────
def download_readme(force: bool = False) -> str:
"""README.md를 다운로드하고 캐시한다.
네트워크 실패 시 캐시된 파일을 사용한다.
"""
if not force and _is_cache_valid():
cached = _load_cache()
if cached:
return cached
try:
resp = httpx.get(README_URL, timeout=15, follow_redirects=True)
resp.raise_for_status()
content = resp.text
_save_cache(content)
print("README.md 다운로드 완료 (최신)")
return content
except (httpx.HTTPError, httpx.TimeoutException) as e:
cached = _load_cache()
if cached:
print(f"네트워크 오류 ({e}). 캐시된 파일을 사용합니다.")
return cached
print(f"오류: README를 다운로드할 수 없고 캐시도 없습니다. ({e})")
sys.exit(1)
# ─── 파싱 ────────────────────────────────────────────────────
def parse_servers(readme: str) -> list[dict]:
"""README에서 MCP 서버 목록을 파싱한다.
서버 항목 형식:
<img .../> **[Name](url)** - Description
또는:
- **[Name](url)** - Description
"""
servers: list[dict] = []
# 패턴: **[Name](URL)** 뒤에 설명이 오는 형태
pattern = re.compile(
r"\*\*\[([^\]]+)\]\(([^)]+)\)\*\*" # **[Name](URL)**
r"\s*[-–—:]\s*" # 구분자
r"(.+)" # 설명
)
for line in readme.splitlines():
m = pattern.search(line)
if not m:
continue
name = m.group(1).strip()
url = m.group(2).strip()
description = m.group(3).strip()
# 설명에서 후행 마크다운 정리
description = re.sub(r"\s*\[.*?\]\(.*?\)\s*$", "", description)
description = description.rstrip(" .")
# GitHub URL에서 패키지명 추정
package = _guess_package(name, url)
servers.append(
{
"name": name,
"url": url,
"description": description,
"package": package,
}
)
return servers
def _guess_package(name: str, url: str) -> str:
"""GitHub URL에서 npm 패키지명을 추정한다."""
# 잘 알려진 매핑
known: dict[str, str] = {
"Slack": "@anthropic/slack-mcp",
"GitHub": "@github/github-mcp-server",
"Notion": "@notionhq/notion-mcp-server",
"Linear": "@linear/linear-mcp-server",
"Google Maps": "@anthropic/google-maps-mcp",
"Google Drive": "@anthropic/google-drive-mcp",
"Puppeteer": "@anthropic/puppeteer-mcp",
"Filesystem": "@anthropic/filesystem-mcp",
"PostgreSQL": "@anthropic/postgres-mcp",
"Sentry": "@anthropic/sentry-mcp",
"Memory": "@anthropic/memory-mcp",
"Brave Search": "@anthropic/brave-search-mcp",
"Fetch": "@anthropic/fetch-mcp",
"Exa": "exa-mcp-server",
"Supabase": "@supabase/mcp-server-supabase",
}
if name in known:
return known[name]
# GitHub URL에서 org/repo 추출
gh_match = re.match(r"https?://github\.com/([^/]+)/([^/#]+)", url)
if gh_match:
org, repo = gh_match.group(1), gh_match.group(2)
# npm scoped package 추정: @org/repo
return f"@{org}/{repo}"
return name.lower().replace(" ", "-")
# ─── 환경변수 추정 ───────────────────────────────────────────
_ENV_HINTS: dict[str, dict[str, str]] = {
"slack": {"SLACK_BOT_TOKEN": "${SLACK_BOT_TOKEN}"},
"github": {"GITHUB_TOKEN": "${GITHUB_TOKEN}"},
"notion": {"NOTION_API_KEY": "${NOTION_API_KEY}"},
"linear": {"LINEAR_API_KEY": "${LINEAR_API_KEY}"},
"google-maps": {"GOOGLE_MAPS_API_KEY": "${GOOGLE_MAPS_API_KEY}"},
"google-drive": {"GOOGLE_DRIVE_CREDENTIALS": "${GOOGLE_DRIVE_CREDENTIALS}"},
"brave-search": {"BRAVE_API_KEY": "${BRAVE_API_KEY}"},
"sentry": {"SENTRY_AUTH_TOKEN": "${SENTRY_AUTH_TOKEN}"},
"postgres": {"POSTGRES_URL": "${POSTGRES_URL}"},
"supabase": {
"SUPABASE_ACCESS_TOKEN": "${SUPABASE_ACCESS_TOKEN}",
"SUPABASE_PROJECT_REF": "${SUPABASE_PROJECT_REF}",
},
"exa": {"EXA_API_KEY": "${EXA_API_KEY}"},
"firebase": {"FIREBASE_TOKEN": "${FIREBASE_TOKEN}"},
"mongodb": {"MONGODB_URI": "${MONGODB_URI}"},
"stripe": {"STRIPE_SECRET_KEY": "${STRIPE_SECRET_KEY}"},
"twilio": {
"TWILIO_ACCOUNT_SID": "${TWILIO_ACCOUNT_SID}",
"TWILIO_AUTH_TOKEN": "${TWILIO_AUTH_TOKEN}",
},
}
def _guess_env(name: str, package: str) -> dict[str, str]:
"""서버명/패키지명에서 필요한 환경변수를 추정한다."""
key = name.lower().replace(" ", "-")
if key in _ENV_HINTS:
return _ENV_HINTS[key]
# 패키지명에서도 시도
for hint_key, env_vars in _ENV_HINTS.items():
if hint_key in package.lower():
return env_vars
# 범용: 서버명 기반 토큰
token_name = re.sub(r"[^A-Z0-9]", "_", name.upper()) + "_API_KEY"
return {token_name: f"${{{token_name}}}"}
# ─── 검색 ────────────────────────────────────────────────────
def search_servers(keyword: str, servers: list[dict]) -> list[dict]:
"""키워드로 서버를 검색한다 (대소문자 무시)."""
kw = keyword.lower()
results = []
for s in servers:
if (
kw in s["name"].lower()
or kw in s["description"].lower()
or kw in s["package"].lower()
or kw in s["url"].lower()
):
results.append(s)
return results
def print_search_results(results: list[dict], keyword: str) -> None:
"""검색 결과를 보기 좋게 출력한다."""
if not results:
print(f'"{keyword}"에 대한 검색 결과가 없습니다.')
return
print(f'"{keyword}" 검색 결과: {len(results)}건\n')
for i, s in enumerate(results, 1):
env = _guess_env(s["name"], s["package"])
env_str = ", ".join(env.keys())
print(f" {i}. {s['name']} ({s['package']})")
print(f" {s['description']}")
print(f" 설치: npx -y {s['package']}")
if env_str:
print(f" 환경변수: {env_str}")
print(f" GitHub: {s['url']}")
print()
# ─── .mcp.json 생성 ─────────────────────────────────────────
def generate_config(server_query: str, servers: list[dict]) -> str | None:
"""서버에 대한 .mcp.json 설정 예시를 JSON으로 생성한다."""
# 정확한 패키지명 매칭 우선
match = None
for s in servers:
if s["package"] == server_query or s["name"].lower() == server_query.lower():
match = s
break
# 부분 매칭
if not match:
results = search_servers(server_query, servers)
if len(results) == 1:
match = results[0]
elif len(results) > 1:
print(f'"{server_query}"에 대한 결과가 여러 개입니다. 더 구체적으로 지정하세요:\n')
for s in results:
print(f" - {s['package']} ({s['name']})")
return None
else:
print(f'"{server_query}"에 해당하는 서버를 찾을 수 없습니다.')
return None
# 설정명: 패키지에서 간단한 이름 추출
config_name = match["name"].lower().replace(" ", "-")
env = _guess_env(match["name"], match["package"])
config = {
config_name: {
"command": "npx",
"args": ["-y", match["package"]],
"env": env,
}
}
return json.dumps(config, indent=2, ensure_ascii=False)
# ─── CLI ─────────────────────────────────────────────────────
def main() -> None:
if len(sys.argv) < 2:
print(__doc__)
sys.exit(0)
command = sys.argv[1].lower()
if command == "download":
download_readme(force=True)
print("캐시가 갱신되었습니다.")
elif command == "search":
if len(sys.argv) < 3:
print("사용법: python mcp_servers.py search <keyword>")
sys.exit(1)
keyword = " ".join(sys.argv[2:])
readme = download_readme()
servers = parse_servers(readme)
results = search_servers(keyword, servers)
print_search_results(results, keyword)
elif command == "generate":
if len(sys.argv) < 3:
print("사용법: python mcp_servers.py generate <server_name_or_package>")
sys.exit(1)
query = " ".join(sys.argv[2:])
readme = download_readme()
servers = parse_servers(readme)
config_json = generate_config(query, servers)
if config_json:
print(f"\n.mcp.json 설정 예시:\n")
print(config_json)
else:
print(f'알 수 없는 명령: "{command}"')
print(__doc__)
sys.exit(1)
if __name__ == "__main__":
main()
My Context Sync
흩어진 정보를 한곳에 모아 정리하는 스킬.
4개 소스에서 최근 정보를 수집하고, 하나의 마크다운 문서로 통합한다.
소스 정의
<!-- ============================================ --> <!-- 아래 4개 소스는 Block 6~9에서 하나씩 채워집니다 --> <!-- 각 블록에서 도구를 연결한 뒤 STUB을 실제 내용으로 교체합니다 --> <!-- ============================================ -->
소스 1: Slack
<!-- 🔧 Block 6에서 채움 (연결 방법: Connector) -->
| 항목 | 값 |
|---|---|
| 연결 방법 | [STUB - Block 6에서 Connector로 연결] |
| 수집 범위 | 최근 7일 |
수집할 채널 목록:
channels:
- name: "[STUB - Block 6에서 설정]"
- name: "[STUB - Block 6에서 설정]"수집 방법:
[STUB - Block 6에서 Connector 연결 후 작성]추출할 정보:
- 중요 공지사항
- 의사결정 사항 ("확정", "결정", "합의" 키워드)
- 나에게 멘션된 메시지
- 답장이 필요한 질문
소스 2: Notion
<!-- 🔧 Block 7에서 채움 (연결 방법: claude mcp add) -->
| 항목 | 값 |
|---|---|
| 연결 방법 | [STUB - Block 7에서 claude mcp add로 연결] |
| 수집 범위 | 지정된 데이터베이스 |
databases:
- name: "[STUB - Block 7에서 설정]"
id: "[STUB]"수집 방법:
[STUB - Block 7에서 MCP 서버 연결 후 작성]추출할 정보:
- 진행 중인 태스크
- 기한이 임박한 항목
- 최근 업데이트된 페이지
소스 3: Linear
<!-- 🔧 Block 8에서 채움 (연결 방법: Official Plugin) -->
| 항목 | 값 |
|---|---|
| 연결 방법 | [STUB - Block 8에서 /plugin install로 연결] |
| 수집 범위 | 나에게 할당된 이슈 |
수집 방법:
[STUB - Block 8에서 Plugin 설치 후 작성]추출할 정보:
- 진행 중인 이슈
- 이번 주 마감 이슈
- 최근 댓글/업데이트
소스 4: Google Calendar / Gmail
<!-- 🔧 Block 9에서 채움 (연결 방법: Plugin 구조 분석 + 설치) -->
| 항목 | 값 |
|---|---|
| 연결 방법 | [STUB - Block 9에서 커뮤니티 Plugin으로 연결] |
| 수집 범위 | 오늘 ~ 7일 후 (Calendar) / 최근 7일 (Gmail) |
수집 방법:
[STUB - Block 9에서 Plugin 설치 후 작성]추출할 정보:
- 오늘의 일정 + 이번 주 주요 미팅
- 안 읽은 이메일 요약
- 회신이 필요한 이메일
- 준비가 필요한 미팅
실행 흐름
<!-- 🔧 Block 10에서 완성 -->
이 스킬이 트리거되면 아래 순서로 실행한다.
1단계: 병렬 수집
4개 소스를 동시에 수집한다. 서로 의존성이 없으므로 병렬 실행이 가능하다.
수집 시작
├── [소스 1] Slack 채널 메시지 수집 ─┐
├── [소스 2] Notion 태스크 수집 ├── 병렬 실행
├── [소스 3] Linear 이슈 수집 │
└── [소스 4] Google Calendar/Gmail 수집 ─┘
수집 완료각 소스 수집은 subagent(Agent 도구)로 실행한다:
[STUB - Block 10에서 소스별 Agent 호출 구체화]2단계: 결과 통합
수집된 정보를 하나의 문서로 합친다.
통합 규칙:
- 소스별 섹션으로 구분
- 각 섹션에서 "하이라이트" (중요 항목 3개 이내)를 선별
- 액션 아이템을 문서 하단에 모아서 정리
- 수집 실패한 소스는 "수집 실패" 표시와 함께 사유 기록
3단계: 문서 저장
결과 파일을 저장한다.
저장 위치: sync/YYYY-MM-DD-context-sync.md4단계: 리포트
[STUB - Block 10에서 리포트 형식 구체화]출력 포맷
<!-- 🔧 Block 10에서 완성 -->
[STUB - Block 10에서 출력 형식 선택 후 작성]
옵션:
1. Markdown 파일 (기본) -- sync/YYYY-MM-DD-context-sync.md에 저장
2. + Slack 메시지 -- 지정 채널에 요약 발송
3. + Notion 페이지 -- 지정 DB에 기록커스터마이징 가이드
소스 추가하기
새로운 소스를 추가하려면 "소스 정의" 섹션에 같은 형식으로 추가한다:
### 소스 5: {도구명}
| 항목 | 값 |
|------|-----|
| 연결 방법 | `{연결 방법}` |
| 수집 범위 | {범위} |
수집 방법:
{MCP 호출 방법 또는 스크립트 실행 방법}
추출할 정보:
- {항목 1}
- {항목 2}소스 제거하기
사용하지 않는 소스는 해당 "소스 N" 섹션 전체를 삭제한다. 실행 흐름의 병렬 수집 부분에서도 해당 줄을 제거한다.
수집 주기 변경하기
기본은 수동 실행이다. 자동 실행을 원하면 CLAUDE.md에 스케줄을 추가한다:
## 스케줄
- context-sync: 매일 09:00 실행Related skills
How it compares
Use this lesson skill for guided Claude Code MCP onboarding; use server-specific MCP catalogs when you only need tool discovery without protocol fundamentals.
FAQ
What does day2-mcp-and-context-sync do?
AI Native Camp Day 2 MCP & Context Sync. MCP를 배우고 나만의 Context Sync 스킬을 만든다. "2일차", "Day 2", "MCP", "context sync" 요청에 사용.
When should I use day2-mcp-and-context-sync?
During build integrations work for ai & agent building.
Is day2-mcp-and-context-sync safe to install?
Review the Security Audits panel on this listing before production use.