references/block0-concept.md
# 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
```json
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와 외부 도구 연결을 하나로 통일합니다."
references/block1-add-server.md
# 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 (가장 추천)
```bash
# 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 (내 컴퓨터에서 실행)
```bash
# 파일 시스템 접근 서버
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` | 내 컴퓨터 전체 | 모든 프로젝트에서 나만 |
```bash
# 모든 프로젝트에서 쓸 서버 추가
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` 파일이 생긴다. 내용은 이런 형태다:
```json
{
"mcpServers": {
"notion": {
"type": "http",
"url": "https://mcp.notion.com/mcp"
}
}
}
```
이 파일을 git에 커밋하면 팀원도 같은 MCP 서버를 쓸 수 있다. 하지만 **직접 편집할 필요는 없다.** `claude mcp add/remove` 명령어가 이 파일을 자동으로 관리해준다.
</details>
## EXECUTE
실제로 MCP 서버를 하나 추가해보자. 아래 중 하나를 선택해서 실행한다:
**옵션 A: Context7 (프로그래밍 문서 검색 — 추천)**
```bash
claude mcp add --transport stdio context7 -- npx -y @upstash/context7-mcp@latest
```
> Context7은 라이브러리 공식 문서를 실시간으로 검색해주는 MCP 서버다.
**옵션 B: Notion (노션 사용자)**
```bash
claude mcp add --transport http notion https://mcp.notion.com/mcp
```
**옵션 C: Fetch (웹페이지 가져오기)**
```bash
claude mcp add --transport stdio fetch -- npx -y @anthropic-ai/mcp-fetch@latest
```
설치 후 확인:
```bash
claude mcp list
```
> 방금 추가한 서버가 목록에 보이면 성공!
> Claude Code를 재시작해야 적용되는 경우가 있다. 새 세션을 시작해보자.
## QUIZ
```json
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. 이 두 가지만 기억하면 됩니다."
references/block10-finalize.md
# 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: 출력 형식 선택
```json
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: 병렬 수집
```json
AskUserQuestion({
"questions": [{
"question": "\"병렬 수집\"의 가장 큰 장점은 무엇인가요?",
"header": "Quiz 10-1",
"options": [
{"label": "하나가 실패하면 전체가 멈춘다", "description": "오히려 독립 실행이라 다른 소스에 영향 없음"},
{"label": "여러 소스를 동시에 수집하여 시간을 절약한다", "description": "각 subagent가 독립적으로 동시 실행"},
{"label": "데이터를 더 정확하게 수집한다", "description": "정확도는 병렬/순차와 무관"}
],
"multiSelect": false
}]
})
```
정답: 2번. 병렬 수집은 여러 소스를 **동시에** 수집하여 시간을 대폭 절약한다. 4개 소스를 순차적으로 하면 120초 걸릴 것을, 동시에 하면 30초면 된다.
### Quiz 10-2: 출력 형식
```json
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가지 연결 방법
```json
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 종합
```json
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의 핵심입니다. 내일부터는 이 스킬을 기반으로 더 발전시켜 나갑니다!"
references/block2-mcp-command.md
# 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
```json
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는 '지금 뭐가 연결되어 있지?' 할 때 씁니다."
references/block3-popular-servers.md
# 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
```json
AskUserQuestion({
"questions": [{
"question": "MCP 서버를 선택할 때 가장 좋은 기준은?",
"header": "Quiz 3",
"options": [
{"label": "내가 매일 쓰는 도구부터 1~2개", "description": "실제 업무에서 바로 활용할 수 있는 것"},
{"label": "인기 순위 1위부터 전부 설치", "description": "안 쓰는 서버는 리소스 낭비"},
{"label": "가장 기술적으로 복잡한 것", "description": "복잡할수록 좋은 게 아님"}
],
"multiSelect": false
}]
})
```
정답: 1번.
피드백: "맞습니다! 매일 쓰는 도구부터 연결하면 바로 체감할 수 있습니다. 나중에 필요할 때 하나씩 추가하면 됩니다."
references/block4-plugin-mcp.md
# 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-marketplace
```
> superpowers는 TDD, 디버깅, 코드리뷰 등 개발 워크플로우를 강화하는 플러그인이다.
**3단계: 설치된 플러그인의 MCP 확인**
플러그인을 설치한 후 `/mcp`를 실행해서 플러그인이 자동으로 추가한 MCP 서버가 있는지 확인한다:
```
/mcp
```
> 플러그인에 MCP 서버가 포함되어 있으면 자동으로 목록에 나타난다.
## QUIZ
```json
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 서버까지 자동 연결됩니다."
references/block5-template-creation.md
# 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 (구조 분석) | **Google** | 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
```json
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개 도구를 각각 다른 방법으로 연결하면서 이 스킬을 점진적으로 완성한다.
references/block6-connector-slack.md
# 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 사용 여부 확인
```json
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을 실제 내용으로 교체:
```markdown
### 소스 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
```json
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 키 없이 브라우저 로그인만으로** 연결된다는 것이다. 비개발자에게 가장 친절한 방법이다.
references/block7-mcp-add-notion.md
# 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/
└── ...
```
파일 안에는 "어떤 서버를, 어떻게 연결할지"가 적혀 있다:
```json
{
"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 사용 여부 확인
```json
AskUserQuestion({
"questions": [{
"question": "Notion을 사용하고 계신가요?",
"header": "Notion 확인",
"options": [
{"label": "네, Notion 사용합니다", "description": "Notion MCP 서버로 연결합니다"},
{"label": "아니요, 다른 도구로 할게요", "description": "mcp_servers.py로 대체 서버를 검색합니다"}
],
"multiSelect": false
}]
})
```
### Step 2: MCP 서버 등록
**Notion을 사용하는 경우:**
Claude가 아래 명령어를 실행한다:
```bash
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** 섹션을 채운다.
```markdown
### 소스 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
```json
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`** 파일이 자동으로 생성/업데이트된다. 어떤 서버를 어떻게 연결할지 적어놓는 설정 파일이다.
references/block8-plugin-linear.md
# 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 사용 여부 확인
```json
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 설치
```bash
/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** 섹션을 채운다.
```markdown
### 소스 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
```json
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 + 스킬 + 설정을 한꺼번에 설치**하기 때문이다. 스마트홈 패키지처럼 설치 한 줄이면 모든 것이 한 번에 구성된다.
references/block9-skill-google.md
# 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** | **Google** | **★★★★** | **구조 이해 + 설치** |
### Plan B: Google 서비스가 없다면?
Google Calendar/Gmail을 사용하지 않는다면, Plugin의 구조 분석만 진행하고 소스 4를 비워둘 수 있다. 구조를 이해하는 것 자체가 이 블록의 핵심 배움이다.
## EXECUTE
### Step 1: 커뮤니티 Plugin Marketplace 추가
```bash
/plugin marketplace add team-attention/plugins-for-claude-natives
```
이 명령어로 team-attention의 Plugin marketplace를 등록한다.
### Step 2: 도구 선택
```json
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 설치
선택한 도구에 따라 설치한다:
```bash
# Google Calendar 선택 시
/plugin install google-calendar
# Gmail 선택 시
/plugin install gmail
# 둘 다 선택 시
/plugin install google-calendar
/plugin install gmail
```
### Step 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** 섹션을 채운다.
```markdown
### 소스 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
```json
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을 만들 수 있다.** "쓸 줄 아는 사람"에서 "만들 줄 아는 사람"으로 레벨업하는 것이다.
scripts/mcp_servers.py
#!/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()
SKILL.md
---
name: day2-mcp-and-context-sync
description: 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 서버 연결 방식. 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로 실행한다:
```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 | Google | Plugin 구조 분석 + Google 연결 |
| 10 | — | 전체 | 병렬 수집 + Output + 최종 실행 |
```json
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부터 진행한다.
templates/context-sync.md
---
name: my-context-sync
description: 나의 컨텍스트 싱크. 여러 소스에서 정보를 수집하고 하나의 문서로 정리한다. "싱크", "sync", "정보 수집" 요청에 사용.
triggers:
- "싱크"
- "sync"
- "정보 수집"
- "컨텍스트 싱크"
---
# My Context Sync
흩어진 정보를 한곳에 모아 정리하는 스킬.
4개 소스에서 최근 정보를 수집하고, 하나의 마크다운 문서로 통합한다.
## 소스 정의
<!-- ============================================ -->
<!-- 아래 4개 소스는 Block 6~9에서 하나씩 채워집니다 -->
<!-- 각 블록에서 도구를 연결한 뒤 STUB을 실제 내용으로 교체합니다 -->
<!-- ============================================ -->
### 소스 1: Slack
<!-- 🔧 Block 6에서 채움 (연결 방법: Connector) -->
| 항목 | 값 |
|------|-----|
| 연결 방법 | `[STUB - Block 6에서 Connector로 연결]` |
| 수집 범위 | 최근 7일 |
수집할 채널 목록:
```yaml
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로 연결]` |
| 수집 범위 | 지정된 데이터베이스 |
```yaml
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.md
```
### 4단계: 리포트
```
[STUB - Block 10에서 리포트 형식 구체화]
```
## 출력 포맷
<!-- 🔧 Block 10에서 완성 -->
```
[STUB - Block 10에서 출력 형식 선택 후 작성]
옵션:
1. Markdown 파일 (기본) -- sync/YYYY-MM-DD-context-sync.md에 저장
2. + Slack 메시지 -- 지정 채널에 요약 발송
3. + Notion 페이지 -- 지정 DB에 기록
```
## 커스터마이징 가이드
### 소스 추가하기
새로운 소스를 추가하려면 "소스 정의" 섹션에 같은 형식으로 추가한다:
```markdown
### 소스 5: {도구명}
| 항목 | 값 |
|------|-----|
| 연결 방법 | `{연결 방법}` |
| 수집 범위 | {범위} |
수집 방법:
{MCP 호출 방법 또는 스크립트 실행 방법}
추출할 정보:
- {항목 1}
- {항목 2}
```
### 소스 제거하기
사용하지 않는 소스는 해당 "소스 N" 섹션 전체를 삭제한다.
실행 흐름의 병렬 수집 부분에서도 해당 줄을 제거한다.
### 수집 주기 변경하기
기본은 수동 실행이다. 자동 실행을 원하면 CLAUDE.md에 스케줄을 추가한다:
```markdown
## 스케줄
- context-sync: 매일 09:00 실행
```