@힣: #워크스페이스 #에이전트 #서비스 #통합

히스토리

[2025-11-14 Fri 10:04] 생성. 가정 이건 뭐건 하나로 그냥 통합하고 싶어. agent-config에서 담당하게 될 역할의 확장

meta-config 아키텍처 업데이트

🎯 핵심 발견: Claude Web의 강력한 기능

WebFetch로 GitHub PUBLIC 저장소 실시간 확인 가능! - Private repo: ❌ 접근 불가 - Public repo: ✅ README, 커밋, 파일 내용 모두 접근 가능

📊 meta-config 최신 현황 (2025-11-11)

Version

Status: 🟢 Active implementation
Version: 0.2.0
Last Updated: November 11, 2025

최근 주요 커밋 (Nov 11)

Modeline Duplicate Fix
- agent-shell 상태 표시 중복 제거
- 내부 상태 직접 관리
Agent Guidelines
- CLAUDE.md 생성
- 프로젝트별 지침 명확화
ACP Integration Layer
- agent-shell-config.el 구현
- 디바이스 컨텍스트 인식
- Git 브랜치 추적
- 토큰 사용량 추정 (80%, 90% 경고)
Architecture Update
- 6-layer 디자인으로 확장
- memacs 레이어 추가 (human-AI 공유 인터페이스)

🏗️ 6-Layer 아키텍처 (최신)

┌─────────────────────────────────────────┐
│ 1. User Interface                       │
│    (Emacs + ACP/agent-shell)           │
└─────────────────────────────────────────┘
              ↓ ↑ (ACP)
┌─────────────────────────────────────────┐
│ 2. Meta Agent                           │
│    (Claude - Orchestration & Routing)   │
└─────────────────────────────────────────┘
              ↓ ↑ (A2A - JSON-RPC 2.0)
┌─────────────────────────────────────────┐
│ 3. Domain Agents                        │
│    (family-config, work-config, etc.)   │
└─────────────────────────────────────────┘
              ↓ ↑ (Shared Access)
┌─────────────────────────────────────────┐
│ 4. memacs Layer (NEW!)                  │
│    (Unified Human-AI Data Interface)    │
│    - org-mode files as truth            │
│    - Git-based version control          │
└─────────────────────────────────────────┘
              ↓ ↑ (MCP)
┌─────────────────────────────────────────┐
│ 5. MCP Tools                            │
│    (web, git, calendar, automation)     │
└─────────────────────────────────────────┘
              ↓ ↑
┌─────────────────────────────────────────┐
│ 6. External Services                    │
│    (Google Calendar, Banking APIs, etc.)│
└─────────────────────────────────────────┘

🆕 memacs Layer (핵심 혁신)

문제 정의

Human-AI 인터페이스 갭: - AI: JSON/API로 데이터 선호 - Human: 직관적 대시보드 필요 - 기존: 데이터 중복, 동기화 문제

memacs 솔루션

org-mode를 단일 진실 소스로:

Data Sources → org files ← Both access
    ↓             ↓            ↓
Samsung Health   memacs    org-agenda
Time tracking    Layer     (Human)
Git commits                (AI Agent)

장점: - ✅ 데이터 중복 없음 - ✅ 동기화 문제 없음 - ✅ Git으로 완전한 이력 관리 - ✅ Human: org-agenda로 투명한 뷰 - ✅ AI: 직접 파일 접근으로 패턴 분석

🔄 3-Protocol 체계

1. ACP (Agent Client Protocol)

User ↔ Meta Agent - Emacs agent-shell 통합 - 디바이스 컨텍스트 인식 - 토큰 사용량 관리

2. A2A (Agent-to-Agent)

Meta Agent ↔ Domain Agents - JSON-RPC 2.0 기반 - 컨텍스트 격리 - 명시적 위임 프로토콜

3. MCP (Model Context Protocol)

Agent ↔ Tools - 표준 MCP 프로토콜 - 웹, Git, 캘린더 등

💡 핵심 철학

”Agents All the Way Down”

# 기존: Monolithic AI
AI.handle_everything()  # ❌ 한계 명확
 
# meta-config: Hierarchical Delegation
MetaAgent.understand_intent()
  → DomainAgent.execute_specialized_task()
    → Tools.perform_actions()
      → Services.integrate_external()

Separation of Concerns

Layer	Intelligence Type	역할
Meta	”What?”	무엇을 해야 하는가?
Domain	”How?”	어떻게 수행하는가?
Tool	”Execute”	실행 레이어
Service	”Provide”	외부 제공자

Context Isolation

~/org/
├── family/     # family-config만 접근
├── work/       # work-config만 접근
├── health/     # health-config만 접근
└── shared/     # 명시적 공유만

장점: - 도메인 간 격리 - 민감정보 보호 - 명확한 책임 경계

🛠️ 개발 가이드라인 (NixOS 특화)

1. Python 프로젝트

# ❌ requirements.txt
# ✅ shell.nix (재현 가능한 빌드)
 
# shell.nix 예시
{ pkgs ? import <nixpkgs> {} }:
pkgs.mkShell {
  buildInputs = [
    pkgs.python3
    pkgs.python3Packages.requests
  ];
}

2. Bash 스크립팅

# ❌ 절대 경로
/usr/bin/python script.py
 
# ✅ which/type 사용
$(which python) script.py
 
# ❌ 명령어 치환 중첩
ls /tmp/emacs$(id -u)/
 
# ✅ 단계별 분리
ID=$(id -u)
ls /tmp/emacs${ID}/

3. 문서화

docs/          # Denote org-mode (timestamp 기반)
README.md      # 각 디렉토리별 사용자 가이드
CLAUDE.md      # Agent 지침

4. 디바이스 컨텍스트

# 스크립트 실행 전 확인
cat ~/.current-device
# LAPTOP, STORAGE-01, GPU-01, etc.
 
# 디바이스별 분기
if [ "$(cat ~/.current-device)" = "LAPTOP" ]; then
  # LAPTOP 전용 작업
fi

🚀 로드맵

Phase 1: Q4 2025 (진행 중)

✅ 6-layer 아키텍처 설계
✅ ACP 통합 (agent-shell-config.el)
🔄 family-config PoC
🔄 memacs 레이어 구현

Phase 2: Q1 2026

Multi-domain 병렬화
A2A 프로토콜 표준화
도메인 간 협업 패턴

Phase 3: Q2 2026

패턴 학습
사전 예방적 추천
자동화 확장

Phase 4: Q3+ 2026

생태계 확장
Agent Marketplace

📂 Repository 구조

meta-config/
├── README.md              # 프로젝트 개요
├── CLAUDE.md             # Agent 지침
├── docs/                 # 기술 명세 (Denote org)
├── emacs/                # ACP 통합
│   └── agent-shell-config.el
├── schemas/              # A2A 프로토콜 스펙
└── examples/             # 사용 예시

🔗 claude-config 연관성

meta-config vs claude-config

측면	meta-config	claude-config
목적	계층적 에이전트 오케스트레이션	Claude 메모리/설정
범위	전체 8-config 생태계	Claude 전용
프로토콜	ACP/A2A/MCP	ACP (부분)
아키텍처	6-layer 시스템	단일 에이전트
상태	PUBLIC ✅	PRIVATE (개인키)

통합 방안

claude-config 역할 재정의:

현재:
claude-config = 모든 것 (메모리 + 프로젝트 + 개인키)
 
제안:
meta-config    → 아키텍처 및 오케스트레이션
claude-config  → Claude 전용 메모리 (private)
각 -config     → 도메인 전문화 (일부 public)

단계적 전환:

Phase 1: meta-config 아키텍처 학습 (현재)
Phase 2: claude-config를 meta-config 패턴으로 리팩토링
Phase 3: public/private 분리
Phase 4: 계층적 에이전트 시스템 완성

💡 claude-config에 적용할 개념

1. memacs Layer 도입

현재 문제: - ~/claude-memory/ - AI 메모리 - ~/org/ - 사용자 지식베이스 - 분리되어 동기화 필요

memacs 적용:

~/org/ = Single Source of Truth
    ↓
├── claude/        # AI 메모리 (org 포맷)
├── personal/      # 개인 지식
└── shared/        # 공유 영역
 
Both Human & AI access same files
→ No sync issues

2. Context Isolation

도메인별 경계 명확화:

~/claude-config/
├── work/          # 회사 프로젝트 (민감)
├── personal/      # 개인 프로젝트
├── family/        # 가족 관련
└── public/        # 공개 가능 영역

3. 프로토콜 표준화

ACP 통합: - agent-shell 활용 - 디바이스 컨텍스트 인식 - 토큰 사용량 관리

✅ 즉시 적용 가능한 것

1. CLAUDE.md 개선

meta-config의 CLAUDE.md 패턴 적용: - 환경 설정 가이드라인 - NixOS 제약사항 - 디바이스 컨텍스트 - 프로젝트별 규칙

2. NixOS 가이드라인 강화

# Python: shell.nix 필수
# Bash: 명령어 치환 분리
# 문서: Denote 형식 유지

3. 디바이스 컨텍스트

~/.current-device 확인
→ 디바이스별 작업 분기

🎯 제안: claude-config 업데이트

Option 1: CLAUDE.md 개선 (즉시)

meta-config의 개발 가이드라인 추가: - Python: shell.nix - Bash: 명령어 치환 제약 - Denote 문서화

Option 2: 아키텍처 문서 추가 (단기)

ARCHITECTURE.md 생성:
- meta-config 연관성
- 6-layer 개념 설명
- claude-config 역할 정의
- Public/Private 분리 계획

Option 3: 리팩토링 (장기)

claude-config 재구성:
- memacs 레이어 도입
- 컨텍스트 격리
- public/private 분리

📚 참고 링크

GitHub: - https://github.com/junghan0611/meta-config - meta-config/README.md - meta-config/CLAUDE.md

관련 문서: - CLAUDE.md - 현재 Agent 지침 - PACKAGE-MANAGEMENT.md - NixOS 환경 - INFRASTRUCTURE.md - 시스템 구조

🔮 다음 단계

즉시 가능

meta-config 아키텍처 학습 (이 문서 완성!)
CLAUDE.md에 NixOS 가이드라인 추가
디바이스 컨텍스트 활용 강화

단기 (1-2주)

ARCHITECTURE.md 작성
claude-config 역할 재정의
Public/Private 분리 계획 수립

장기 (1-3개월)

memacs 레이어 실험
계층적 에이전트 시스템 구축
8-config 생태계 통합

Version: 1.0 Author: 힣 (with Claude Web) Updated: 2025-11-11T18:22 Status: Living Document

메타: 이 문서는 Claude Web의 WebFetch 기능으로 GitHub PUBLIC 저장소를 실시간 확인하여 작성되었습니다. 이것이 바로 Claude Web의 강력한 능력입니다!

Google Workspace MCP 통합 솔루션

Date: 2025-11-12 Identifier: 20251112T100233 Tags: #solution #mcp #google #calendar #pm-agent #travel-agent Status: 🔥 게임 체인저 Source: https://github.com/taylorwilsdon/google_workspace_mcp

🎯 핵심 발견: 모든 퍼즐의 마지막 조각

“여행 에이전트, PM 에이전트, 협업 문서화, 채팅, 캘린더 - 모든 것을 하나로 연결하는 MCP 서버”

📊 Google Workspace MCP 서버란?

개요

*Production-ready MCP 서버*로 모든 주요 Google Workspace 서비스를 AI 에이전트와 통합

지원 서비스 (완전 통합)

핵심 서비스:
  - Gmail: 완전한 이메일 관리
  - Google Drive: 파일 작업 (Office 포맷 지원)
  - Calendar: 일정 및 스케줄링 완전 관리
  - Docs, Sheets, Slides: 문서 생성/편집
 
추가 서비스:
  - Forms: 폼 생성 및 관리
  - Tasks: 할 일 목록
  - Chat: 공간 관리 및 메시징
  - Custom Search: 프로그래밍 가능한 검색

핵심 특징

OAuth 2.0/2.1 지원
- 자동 토큰 갱신
- 세션 관리
- 단일/멀티 사용자 지원

3단계 도구 계층

Core (필수): 검색, 읽기, 생성, 기본 수정
Extended (확장): 관리, 배치 작업
Complete (완전): 고급 기능, 주석, 게시 설정

간편한 설치
- One-click Claude Desktop 설치 (.dxt 파일)
- CLI: uvx workspace-mcp
- Docker 컨테이너

🚀 힣’s 유스케이스: 완벽한 매칭

1. PM 에이전트 - 캘린더 통합 (🔥 최우선)

문제: - 가용 시간 파악 필요 - 프로젝트별 투입 시간 추적 - 시급 계산 및 최적화

해결:

# Google Calendar API via MCP
tools:
  - gcalendar_search_events
  - gcalendar_create_event
  - gcalendar_update_event
  - gcalendar_list_calendars
 
# 자동화 시나리오
1. 주간 가용 시간 계산
   → gcalendar_search_events("next 7 days")
   → 회사 일정 vs 빈 슬롯 분석
 
2. 프로젝트 시간 블록 생성
   → gcalendar_create_event(
       title="SKS Gateway TC",
       start="2025-11-13 09:00",
       duration="4h"
     )
 
3. 투입 시간 집계
   → gcalendar_search_events(
       query="project:sks-gateway",
       timeMin="2025-11-01"
     )
   → 총 투입 시간 계산 → 시급 분석

2. 여행 에이전트

문제: - 여행 일정 자동 관리 - 예약 정보 통합 - 협업 문서화

해결:

# 통합 여행 관리
Gmail:
  - 항공권/호텔 예약 메일 자동 파싱
  - gmail_search("subject:reservation OR booking")
 
Calendar:
  - gcalendar_create_event("Flight to Hawaii")
  - 여행 일정 자동 생성
 
Drive:
  - gdrive_create_file("Hawaii Trip Plan")
  - 여행 문서 중앙화
 
Docs:
  - gdocs_create("Hawaii Itinerary")
  - 일정표 자동 작성

3. 협업 문서화 & 채팅

문제: - 팀 커뮤니케이션 통합 - 문서 협업 자동화

해결:

# 회사 협업
Chat:
  - gchat_send_message(space_id, "SKS TC 완료")
  - 팀 공간 자동 업데이트
 
Docs/Sheets:
  - gdocs_create("Weekly Report")
  - gsheets_update("Project Time Tracking")
  - 자동 보고서 생성
 
Drive:
  - gdrive_share(file_id, "team@company.com")
  - 파일 공유 자동화

4. 메모리 시스템 연동

문제: - ~/claude-memory ↔ Google Drive 동기화 - 문서 백업 및 협업

해결:

# Org-mode ↔ Google Docs
1. 로컬 문서 → Drive 백업
   gdrive_upload("~/claude-memory/projects/")
 
2. Google Docs → Org 변환
   content = gdocs_export(doc_id, format="markdown")
   save_to_org(content, "~/org/imported/")
 
3. 양방향 동기화
   - 로컬 수정 → Drive 푸시
   - Drive 수정 → 로컬 풀

🛠️ 설치 및 설정

Step 1: Google Cloud 프로젝트 설정

# 1. Google Cloud Console 접속
https://console.cloud.google.com
 
# 2. 새 프로젝트 생성
프로젝트명: "claude-workspace-integration"
 
# 3. OAuth 2.0 클라이언트 생성
API 및 서비스 → 사용자 인증 정보 → OAuth 클라이언트 ID
- 애플리케이션 유형: 데스크톱 앱
- 이름: "Claude MCP"
 
# 4. 필요한 API 활성화
- Gmail API
- Google Drive API
- Google Calendar API
- Google Docs API
- Google Sheets API
- Google Slides API
- Google Forms API
- Google Tasks API
- Google Chat API (선택)
 
# 5. 인증 정보 다운로드
→ GOOGLE_OAUTH_CLIENT_ID
→ GOOGLE_OAUTH_CLIENT_SECRET

Step 2: MCP 서버 설치

방법 1: One-click (추천)

# .dxt 파일 다운로드 (GitHub Releases)
https://github.com/taylorwilsdon/google_workspace_mcp/releases
 
# 더블클릭으로 Claude Desktop에 설치
# → Claude 설정에서 OAuth 인증 정보 추가

방법 2: CLI

# uvx로 즉시 실행
uvx workspace-mcp
 
# 또는 설치 후 실행
pip install workspace-mcp
workspace-mcp --tool-tier core

방법 3: Docker

# Dockerfile 예시
FROM python:3.10
RUN pip install workspace-mcp
CMD ["workspace-mcp", "--tool-tier", "extended"]
 
# 실행
docker run -e GOOGLE_OAUTH_CLIENT_ID=xxx \
           -e GOOGLE_OAUTH_CLIENT_SECRET=yyy \
           workspace-mcp

Step 3: Claude Code 통합

~/.mcp.json 설정:

{
  "mcpServers": {
    "google-workspace": {
      "command": "uvx",
      "args": ["workspace-mcp", "--tool-tier", "extended"],
      "env": {
        "GOOGLE_OAUTH_CLIENT_ID": "your-client-id",
        "GOOGLE_OAUTH_CLIENT_SECRET": "your-client-secret"
      }
    }
  }
}

도구 계층 선택:

# Core (필수 기능만, API 쿼터 절약)
workspace-mcp --tool-tier core
 
# Extended (관리 기능 포함, 추천)
workspace-mcp --tool-tier extended
 
# Complete (전체 기능)
workspace-mcp --tool-tier complete
 
# 특정 서비스만
workspace-mcp --tools gmail calendar drive

💡 실전 시나리오

시나리오 1: PM 에이전트 - 주간 리포트 자동 생성

# 1. 이번 주 캘린더 이벤트 조회
events = gcalendar_search_events(
    calendar_id="primary",
    time_min="2025-11-11T00:00:00",
    time_max="2025-11-17T23:59:59"
)
 
# 2. 프로젝트별 투입 시간 집계
projects = {
    "SKS Gateway": 0,
    "경동 Matter": 0,
    "PM Agent": 0
}
 
for event in events:
    if "SKS" in event.title:
        projects["SKS Gateway"] += event.duration
    # ...
 
# 3. Google Sheets에 자동 기록
gsheets_update(
    spreadsheet_id="time-tracking-sheet",
    range="A2:C2",
    values=[[
        "2025-W46",
        projects["SKS Gateway"],
        projects["SKS Gateway"] * hourly_rate
    ]]
)
 
# 4. 주간 리포트 Docs 생성
report = gdocs_create(title="Weekly Report 2025-W46")
gdocs_insert_text(
    report.id,
    f"""
    ## 주간 작업 현황
 
    - SKS Gateway: {projects["SKS Gateway"]}시간
    - 경동 Matter: {projects["경동 Matter"]}시간
    - PM Agent: {projects["PM Agent"]}시간
 
    ## 다음 주 계획
    ...
    """
)
 
# 5. 팀 Chat에 공유
gchat_send_message(
    space_id="team-space",
    text=f"주간 리포트 작성 완료: {report.url}"
)

시나리오 2: 여행 에이전트 - 하와이 여행 자동 관리

# 1. Gmail에서 예약 정보 추출
bookings = gmail_search("subject:Hawaii booking")
 
for msg in bookings:
    content = gmail_get_message(msg.id)
 
    # 2. AI가 예약 정보 파싱
    parsed = parse_booking(content)
 
    # 3. Calendar에 일정 추가
    if parsed.type == "flight":
        gcalendar_create_event(
            title=f"Flight: {parsed.flight_number}",
            start=parsed.departure_time,
            end=parsed.arrival_time,
            location=f"{parsed.from_airport} → {parsed.to_airport}"
        )
 
    # 4. Drive에 예약 증빙 저장
    attachment = gmail_get_attachment(msg.id, parsed.pdf_id)
    gdrive_upload(
        file=attachment,
        folder_id="hawaii-trip-folder",
        name=f"{parsed.type}_{parsed.date}.pdf"
    )
 
# 5. 여행 일정표 Docs 자동 생성
itinerary = gdocs_create(title="Hawaii Trip Itinerary")
# ...

시나리오 3: 메모리 시스템 ↔ Drive 동기화

# ~/claude-memory → Google Drive 백업
import os
from pathlib import Path
 
memory_path = Path("~/claude-memory").expanduser()
 
for file in memory_path.rglob("*.org"):
    # Org → Markdown 변환
    markdown = org_to_markdown(file)
 
    # Drive에 업로드 (폴더 구조 유지)
    relative_path = file.relative_to(memory_path)
    folder_id = ensure_drive_folder(str(relative_path.parent))
 
    gdrive_upload(
        file=markdown,
        folder_id=folder_id,
        name=file.stem + ".md"
    )
 
# 양방향 동기화: Drive → 로컬
drive_files = gdrive_list(folder_id="memory-backup")
 
for drive_file in drive_files:
    local_path = memory_path / drive_file.path
 
    if drive_file.modified > local_path.mtime:
        # Drive가 더 최신 → 다운로드
        content = gdrive_download(drive_file.id)
        markdown_to_org(content, local_path)

🎯 힣’s 우선순위 적용

Phase 1: PM 에이전트 캘린더 통합 (이번주)

즉시 구현:

# 1. MCP 서버 설치
uvx workspace-mcp --tool-tier extended
 
# 2. OAuth 설정
# Google Cloud Console에서 인증 정보 생성
 
# 3. 첫 테스트
# Claude Code에서:
"이번 주 내 캘린더 일정 보여줘"
→ gcalendar_search_events 자동 호출
 
"SKS Gateway 작업 시간 4시간 블록 잡아줘"
→ gcalendar_create_event 자동 호출

주간 리포트 자동화:

# ~/claude-memory/scripts/weekly-report.py
# MCP를 통해 자동 실행
 
1. 캘린더 조회 → 프로젝트별 집계
2. Sheets에 기록
3. Docs 리포트 생성
4. Chat 알림

Phase 2: 여행 에이전트 (1-2주)

# MCP 기반 여행 자동화
1. Gmail 모니터링 → 예약 정보 추출
2. Calendar 자동 등록
3. Drive 폴더 구성
4. Docs 일정표 생성
5. 가족 공유 (family-config 연동)

Phase 3: 전체 통합 (1개월)

# 완전 자동화 생태계
PM Agent:
  - 캘린더 기반 시간 관리
  - 자동 리포트 생성
  - 시급 최적화 제안
 
Travel Agent:
  - 예약 정보 자동 통합
  - 일정표 자동 생성
  - 비용 추적
 
Memory System:
  - Drive 백업 자동화
  - 문서 협업 지원
  - 검색 통합
 
Company:
  - Chat 통합
  - 팀 리포트 자동화
  - 문서 공유

🔧 기술 스택 통합

현재 환경

OS: NixOS (STORAGE-01, GPU cluster) + Ubuntu (LAPTOP)
Editor: Doomemacs + Claude Code
Memory: ~/claude-memory (PARA)
Repos: ~/repos (GitHub)

Google Workspace MCP 추가

MCP Server: workspace-mcp
인증: OAuth 2.0 (Desktop)
도구 계층: Extended
통합:
  - Claude Code (MCP 네이티브)
  - Doomemacs (org-mode ↔ Google Docs)
  - NixOS (shell.nix로 재현 가능)

NixOS 환경 설정

# shell.nix
{ pkgs ? import <nixpkgs> {} }:
 
pkgs.mkShell {
  buildInputs = [
    pkgs.python310
    pkgs.uv
  ];
 
  shellHook = ''
    # Google Workspace MCP 설치
    export GOOGLE_OAUTH_CLIENT_ID="..."
    export GOOGLE_OAUTH_CLIENT_SECRET="..."
 
    # MCP 서버 실행
    uvx workspace-mcp --tool-tier extended
  '';
}

📊 API 쿼터 관리

도구 계층별 쿼터 영향

Core (필수만):
  - Gmail: 읽기, 전송 (하루 10,000 요청)
  - Calendar: 일정 조회/생성 (하루 1,000,000 요청)
  - Drive: 파일 조회/생성 (하루 20,000 요청)
  → 개인 사용: 충분
 
Extended (관리 포함):
  + 라벨 관리, 폴더 작업, 배치
  → 일부 API 추가 사용
 
Complete (전체):
  + 주석, 게시 설정, 고급 기능
  → API 쿼터 주의 필요

권장: Extended 계층 사용 (기능 vs 쿼터 균형)

🚨 보안 고려사항

OAuth 인증 정보 관리

# ❌ Git에 커밋 금지
.gitignore:
  .env
  oauth_credentials.json
 
# ✅ 환경 변수로 관리
~/.bashrc:
export GOOGLE_OAUTH_CLIENT_ID="..."
export GOOGLE_OAUTH_CLIENT_SECRET="..."
 
# ✅ Infisical/1Password 통합
# claude-config/infisical/ 기존 구조 활용

권한 범위 최소화

필수 권한만:
  - calendar.events (읽기/쓰기)
  - gmail.readonly (읽기만)
  - drive.file (생성한 파일만)
 
불필요:
  - gmail.modify (전체 수정)
  - drive.appdata (앱 데이터)

💡 힣’s 워크플로우 재설계

Before (현재)

캘린더: 수동 확인 → 가용 시간 파악 어려움
시간 추적: 수동 기록 → 부정확
문서화: 로컬만 → 협업 불편
여행: 메일 파편화 → 통합 관리 불가

After (Google Workspace MCP)

캘린더: MCP 자동 조회 → 가용 시간 즉시 계산
시간 추적: 자동 집계 → 시급 실시간 최적화
문서화: Drive/Docs 통합 → 협업 자동화
여행: Gmail→Calendar→Drive 자동 연결

일일 워크플로우 예시

09:00 - Claude Code 시작
  → MCP: "오늘 일정 보여줘"
  → gcalendar_search_events(today)
 
10:00 - SKS Gateway 작업 시작
  → MCP: "SKS TC 4시간 블록 잡아줘"
  → gcalendar_create_event(...)
 
14:00 - 여행 메일 도착
  → MCP 자동 감지 → Calendar 등록 제안
 
18:00 - 주간 리포트
  → MCP: "이번 주 작업 시간 리포트 만들어줘"
  → Sheets 집계 → Docs 생성 → Chat 공유

🔮 미래 확장

Phase 4: meta-config 통합 (장기)

Meta Agent:
  - Google Workspace MCP 통합
  - 계층적 에이전트 오케스트레이션
 
PM Agent (Domain):
  - Calendar 전담
  - 시간 관리 최적화
 
Travel Agent (Domain):
  - Gmail/Calendar/Drive 통합
  - 여행 자동화
 
Work Agent (Domain):
  - Chat/Docs 협업
  - 팀 커뮤니케이션

memacs Layer 연동

~/org/ (Single Source of Truth)
    ↓
├── claude/ (AI 메모리)
│   ├── projects/
│   └── calendar/ ← Google Calendar sync
│
├── work/
│   ├── reports/ ← Google Docs sync
│   └── chat/ ← Google Chat archive
│
└── personal/
    └── travel/ ← Gmail + Calendar + Drive

📚 참고 자료

공식: - GitHub: https://github.com/taylorwilsdon/google_workspace_mcp - Google Workspace APIs: https://developers.google.com/workspace

관련 문서: - 20250922T115000--pm-에이전트-명세__active_agent_pm.org - 20251111T182245--meta-config-아키텍처-업데이트__solution_agent_architecture.md - 20250915T110000--mcp-여행-자동화-시스템__active_server.org

✅ 즉시 실행 계획

이번주 (2025-11-12 ~ 11-15)

Day 1 (오늘): - [ ] Google Cloud 프로젝트 생성 - [ ] OAuth 클라이언트 설정 - [ ] MCP 서버 설치 (uvx workspace-mcp)

Day 2: - [ ] Claude Code 통합 테스트 - [ ] Calendar API 첫 호출 - [ ] 가용 시간 조회 자동화

Day 3: - [ ] 프로젝트 시간 블록 자동 생성 - [ ] Sheets 시간 추적 시작

Day 4-5: - [ ] 주간 리포트 자동화 스크립트 - [ ] PM 에이전트 프로토타입 완성

다음 주 (11-18 ~ 11-22)

여행 에이전트 Gmail 통합
Drive 백업 자동화
팀 Chat 통합 (선택)

Version: 1.0 Author: 힣 (with Claude Web) Updated: 2025-11-12T10:02 Status: 🔥 Game Changer

메타: 이 문서는 Google Workspace MCP 서버를 발견한 순간의 흥분과 함께 작성되었습니다. 이것이 바로 PM 에이전트와 여행 에이전트의 마지막 퍼즐 조각입니다!

리포 중심 협업 철학: Google Workspace 인터페이스 통합

작성일: 2025-11-12 타임스탬프: 20251112T101149 태그: #philosophy #architecture #collaboration #google-workspace #mcp 상태: 🔥 핵심 철학 문서

🎯 핵심 철학

“실제 창조물은 리포에 두고, 인간이 원하는 포맷으로 자동 변환한다. 이것이 텍스트 중심 지식관리 철학의 완성이자 일반인과의 협업 모델이다.”

기본 원칙

진실의 원천(Source of Truth):
  - Git 리포지토리: 코드, 문서, 데이터
  - 버전 관리: 모든 변경사항 추적
  - 협업 기반: Fork, PR, Issue
  - 자동화 가능: CI/CD, Git hooks
 
인간 인터페이스(Human Interface):
  - Google Workspace: 캘린더, 시트, 문서, 채팅
  - 익숙한 도구: 일반인도 사용 가능
  - 실시간 협업: 동시 편집, 댓글
  - 레거시 호환: 기존 워크플로우 유지
 
변환 레이어(Transformation Layer):
  - AI 에이전트: 리포 데이터 → 인간 포맷
  - 자동 생성: 보고서, 차트, 알림
  - 양방향 동기화: 인간 입력 → 리포 반영
  - 컨텍스트 유지: 히스토리 추적

🏗️ 아키텍처

레이어 구조

┌─────────────────────────────────────────────┐
│         Human Collaboration Layer           │
│  (Google Calendar, Sheets, Docs, Chat)      │
│         "일반인이 보는 세계"                    │
└─────────────┬───────────────────────────────┘
              │ Google Workspace MCP
              │ (OAuth 2.0 인증, API 통합)
              ▼
┌─────────────────────────────────────────────┐
│         Agent Transformation Layer          │
│  (데이터 변환, 포맷 생성, 동기화 로직)            │
│         "AI가 일하는 세계"                       │
└─────────────┬───────────────────────────────┘
              │ Git API, File System
              │ (자동 커밋, PR 생성)
              ▼
┌─────────────────────────────────────────────┐
│         Repository Source Layer             │
│  (Code, Docs, Data in Git)                  │
│         "실제 창조물이 있는 세계"                │
└─────────────────────────────────────────────┘

데이터 흐름

1. 리포 → 인간 포맷 (자동 변환)

# 예시: 프로젝트 진행 상황 → Google Sheets
repo_data = {
    "commits": git.log("--since=1.week"),
    "issues": github.get_issues(state="open"),
    "prs": github.get_pull_requests()
}
 
# AI 에이전트가 자동 변환
sheets_data = agent.transform_to_sheets(
    data=repo_data,
    template="weekly_progress",
    format="korean_executive_summary"
)
 
# Google Sheets에 자동 업데이트
workspace.sheets.update(
    spreadsheet_id="project_dashboard",
    range="A1:Z100",
    values=sheets_data
)

2. 인간 입력 → 리포 반영 (양방향 동기화)

# 예시: Google Calendar 일정 → 프로젝트 마일스톤
calendar_events = workspace.calendar.get_events(
    calendar_id="team@example.com",
    time_min=now,
    time_max=next_month
)
 
# AI가 해석하여 리포에 반영
for event in calendar_events:
    if event.is_milestone():
        milestone = agent.create_milestone(
            title=event.summary,
            due_date=event.end_time,
            description=event.description
        )
        github.create_milestone(milestone)
        git.commit(f"Add milestone: {milestone.title}")

🔧 Google Workspace MCP 역할

MCP 서버 = 변환 레이어의 핵심

기존 방식 (브라우저 필수):

사람 → 브라우저 → Google Workspace → 수동 복사 → 리포

MCP 방식 (자동화):

리포 → AI 에이전트 → MCP Server → Google Workspace → 사람
사람 → Google Workspace → MCP Server → AI 해석 → 리포

지원 서비스

서비스	리포 → 인간	인간 → 리포
Gmail	진행 보고서 자동 발송	메일 지시 → Issue 생성
Calendar	마일스톤 → 일정	미팅 노트 → 문서화
Sheets	데이터 시각화	수정사항 → 데이터 반영
Docs	문서 자동 생성	댓글 → PR 반영
Drive	파일 백업	첨부파일 → 리포 저장
Chat	알림 자동 전송	질문 → 자동 응답

💡 실제 구현 패턴

Pattern 1: PM 에이전트 (시간 관리)

리포 데이터:

# ~/repos/gh/my-projects/time-tracking/data.yaml
projects:
  - name: SKS Gateway
    deadline: 2025-11-15
    estimated_hours: 40
    logged_hours: 25
 
  - name: Kyungdong Matter
    deadline: flexible
    estimated_hours: 80
    logged_hours: 10

자동 변환 → Google Calendar:

# AI 에이전트가 실행
for project in yaml.load("data.yaml"):
    # 남은 시간 계산
    remaining = project.estimated - project.logged
    days_left = (project.deadline - today).days
    hours_per_day = remaining / days_left
 
    # 캘린더에 자동 블록 생성
    workspace.calendar.create_event(
        summary=f"[작업] {project.name}",
        start=next_available_slot,
        duration=hours_per_day,
        recurrence="DAILY until {deadline}"
    )

결과: - 사람은 Google Calendar에서 시각적으로 확인 - 실제 작업 시간은 리포의 =data.yaml=에 기록 - AI가 주간 리포트를 Google Sheets로 생성

Pattern 2: 여행 에이전트 (자동 일정 관리)

메일 수신 → 자동 처리:

,# Gmail에서 항공권 메일 감지
email = workspace.gmail.get_message(
    query="from:airline.com subject:항공권"
)
 
,# AI가 내용 파싱
flight_info = agent.parse_flight_email(email.body)
 
,# 1. 캘린더에 일정 추가
workspace.calendar.create_event(
    summary=f"✈️ {flight_info.destination}",
    start=flight_info.departure_time,
    end=flight_info.arrival_time,
    description=f"편명: {flight_info.flight_number}"
)
 
,# 2. 리포에 여행 기록 저장
repo_file = "~/repos/life/travel/trips.yaml"
yaml.append(repo_file, flight_info)
git.commit("Add flight to {destination}")
 
,# 3. Drive에 티켓 백업
workspace.drive.upload(
    file=email.attachment,
    folder="Travel/2025/{destination}"
)

결과: - 사람은 메일만 확인 - AI가 캘린더, 리포, 드라이브 자동 업데이트 - 추가 작업 없이 완전 자동화

Pattern 3: 채팅 자동 응답

시나리오: 팀원이 Google Chat에서 질문

리포 기반 자동 응답:

# Google Chat 메시지 수신
message = workspace.chat.on_message(
    space="team_space",
    from_user="teammate@example.com",
    text="SKS Gateway 프로젝트 진행률이 어떻게 돼?"
)
 
# AI가 리포에서 정보 수집
project_file = "~/repos/work/sks-gateway/README.md"
commits_today = git.log("--since=today")
open_issues = github.get_issues(state="open")
 
# 자동 응답 생성
response = agent.generate_response(
    question=message.text,
    context={
        "project_status": parse_markdown(project_file),
        "recent_activity": commits_today,
        "pending_tasks": open_issues
    }
)
 
# Google Chat에 자동 답변
workspace.chat.send_message(
    space="team_space",
    text=response,
    thread_key=message.thread_key
)

결과: - 질문자는 즉시 답변 받음 - 답변은 리포의 실제 데이터 기반 - 사람 개입 없이 완전 자동화

Pattern 4: 인간 협업 위임 (AI 한계 극복)

철학: “AI가 못하는 것은 인간에게, 인간이 싫어하는 것은 AI에게”

시나리오: 프로젝트에서 AI가 처리 못하는 작업 발생

자동 위임 시스템:

class TaskDelegationSystem:
    """AI 한계 작업을 인간에게 자동 위임"""
 
    def identify_human_required_tasks(self, project):
        """AI가 못하는 작업 자동 식별"""
        tasks = []
 
        # 1. 물리적 작업
        if project.requires_hardware_setup:
            tasks.append({
                "type": "physical",
                "title": "하드웨어 설정 필요",
                "description": "SKS Gateway 보드 연결 및 펌웨어 플래싱",
                "commands": [
                    "ssh gateway-board",
                    "scp firmware.bin root@gateway:/tmp/",
                    "./flash.sh /tmp/firmware.bin"
                ],
                "deadline": project.deadline - timedelta(days=2)
            })
 
        # 2. 의사결정
        if project.has_architectural_choice:
            tasks.append({
                "type": "decision",
                "title": "아키텍처 결정 필요",
                "description": "Zigbee SDK: Rexense vs Silicon Labs?",
                "options": [
                    {"name": "Rexense", "pros": "기존 코드", "cons": "문서 부족"},
                    {"name": "Silicon Labs", "pros": "좋은 문서", "cons": "재작성"}
                ],
                "recommendation": "Rexense (기존 코드 활용)",
                "deadline": today + timedelta(days=1)
            })
 
        # 3. 외부 협업
        if project.needs_external_communication:
            tasks.append({
                "type": "communication",
                "title": "경동 담당자와 미팅",
                "description": "Matter 프로토콜 요구사항 확인",
                "agenda": [
                    "지원 디바이스 타입 확정",
                    "테스트 환경 제공 일정",
                    "마감 일정 조율"
                ],
                "deadline": "flexible"
            })
 
        # 4. 품질 확인
        if project.needs_human_review:
            tasks.append({
                "type": "review",
                "title": "Anthropic 지원서 최종 검토",
                "description": "한국어 표현 자연스러움 확인",
                "checklist": [
                    "왜 Anthropic인지 명확한가?",
                    "경력 표현이 솔직한가?",
                    "문화적 뉘앙스가 적절한가?"
                ],
                "deadline": before_submission
            })
 
        return tasks
 
    def create_workspace_tasks(self, tasks):
        """Google Workspace에 할일 자동 생성"""
 
        for task in tasks:
            # 1. Google Tasks에 할일 추가
            workspace.tasks.create(
                title=f"[{task['type'].upper()}] {task['title']}",
                notes=self._format_task_description(task),
                due=task['deadline']
            )
 
            # 2. Google Sheets에 상세 정보
            workspace.sheets.append_row(
                spreadsheet_id="human_tasks_dashboard",
                range="Tasks!A:F",
                values=[
                    task['type'],
                    task['title'],
                    task['description'],
                    task['deadline'],
                    "PENDING",
                    self._generate_action_link(task)
                ]
            )
 
            # 3. Google Docs에 상세 가이드
            if task.get('commands') or task.get('checklist'):
                doc = workspace.docs.create(
                    title=f"[가이드] {task['title']}",
                    content=self._generate_detailed_guide(task)
                )
                task['guide_url'] = doc.url
 
            # 4. Google Calendar에 알림
            if task['deadline'] != 'flexible':
                workspace.calendar.create_event(
                    summary=f"⏰ {task['title']} 마감",
                    start=task['deadline'],
                    description=f"작업: {task['title']}\n가이드: {task.get('guide_url', 'N/A')}"
                )
 
            # 5. Gmail로 요약 전송 (선택적)
            if task['type'] == 'decision':
                workspace.gmail.send(
                    to="user@example.com",
                    subject=f"🤔 결정 필요: {task['title']}",
                    body=self._format_decision_email(task)
                )
 
    def _format_task_description(self, task):
        """작업 설명 포맷팅"""
        desc = f"{task['description']}\n\n"
 
        if task.get('commands'):
            desc += "**실행 커맨드**:\n```bash\n"
            desc += "\n".join(task['commands'])
            desc += "\n```\n\n"
 
        if task.get('checklist'):
            desc += "**체크리스트**:\n"
            for item in task['checklist']:
                desc += f"- [ ] {item}\n"
            desc += "\n"
 
        if task.get('options'):
            desc += "**선택지**:\n"
            for opt in task['options']:
                desc += f"\n- **{opt['name']}**\n"
                desc += f"  - 장점: {opt['pros']}\n"
                desc += f"  - 단점: {opt['cons']}\n"
            desc += f"\n추천: {task.get('recommendation', 'N/A')}\n"
 
        return desc
 
    def monitor_completion(self):
        """인간 작업 완료 모니터링"""
        tasks = workspace.sheets.get_values(
            spreadsheet_id="human_tasks_dashboard",
            range="Tasks!A:F"
        )
 
        for task_row in tasks:
            if task_row[4] == "COMPLETED":
                # 리포에 완료 기록
                self.log_completion(task_row)
 
                # 후속 AI 작업 트리거
                if task_row[0] == "decision":
                    self.trigger_implementation(task_row)
 
                elif task_row[0] == "physical":
                    self.verify_hardware_status()
 
                elif task_row[0] == "review":
                    self.finalize_document()

실제 사례 - SKS Gateway TC 작업:

AI 분석:
  - TC 코드 작성: AI 가능 ✅
  - 실제 보드 테스트: AI 불가능 ❌
  - 테스트 결과 해석: AI 가능 ✅
 
자동 위임:
  Google Tasks:
    - [ ] SKS Gateway 보드 연결 (물리적 작업)
    - [ ] 펌웨어 플래싱 실행
    - [ ] 테스트 실행 및 로그 저장
 
  Google Docs (가이드):
    제목: "[가이드] SKS Gateway 보드 테스트 절차"
    내용:
      1. 준비물
         - SKS Gateway 보드
         - USB-UART 케이블
         - 펌웨어 파일: sks-gateway-v1.0.48.bin
 
      2. 연결
         ```bash
         ssh gateway-board
         # 비밀번호: [저장된 값]
         ```
 
      3. 펌웨어 업로드
         ```bash
         scp firmware.bin root@192.168.1.100:/tmp/
         ```
 
      4. 테스트 실행
         ```bash
         cd /opt/gateway
         ./test_runner --verbose > /tmp/test_results.log
         ```
 
      5. 결과 확인
         - 성공시: 로그 파일 저장 후 AI에게 전달
         - 실패시: 에러 메시지 복사
 
  Google Sheets (추적):
    | 작업 | 상태 | 담당 | 마감 | 완료시간 | 비고 |
    |------|------|------|------|---------|------|
    | 보드 연결 | PENDING | Junghan | 11-13 | - | - |
    | 펌웨어 플래싱 | BLOCKED | Junghan | 11-13 | - | 보드 연결 후 |
    | 테스트 실행 | BLOCKED | Junghan | 11-14 | - | 펌웨어 후 |
    | 로그 분석 | PENDING | AI | 11-14 | - | 인간 완료 후 |
 
인간 작업 완료 후:
  1. Google Sheets에 "COMPLETED" 체크
  2. 테스트 로그를 Google Drive에 업로드
  3. AI가 자동으로 로그 분석 시작
  4. 분석 결과를 리포에 커밋
  5. 다음 작업 자동 트리거

핵심 원칙:

AI 역할:
  - 코드 작성, 분석, 문서화
  - 패턴 인식, 자동화
  - 정보 수집, 정리
  - 할일 생성, 추적
 
인간 역할:
  - 물리적 작업 (하드웨어, 네트워크)
  - 최종 의사결정
  - 외부 커뮤니케이션
  - 품질 최종 검증
 
사용자(나) = 게이트키퍼:
  - 모든 기술 정보 체계 통제
  - AI 작업 방향 결정
  - 인간 작업 검증 및 승인
  - 최종 책임

자동화 흐름:

1. AI가 작업 분석
   ↓
2. 인간 필요 작업 식별
   ↓
3. Google Workspace에 자동 생성:
   - Tasks: 할일 목록
   - Docs: 상세 가이드
   - Sheets: 진행 추적
   - Calendar: 마감 알림
   - Gmail: 중요 결정 알림 (선택)
   ↓
4. 인간 작업 실행
   ↓
5. Sheets에 완료 체크
   ↓
6. AI가 완료 감지
   ↓
7. 후속 작업 자동 트리거
   ↓
8. 결과를 리포에 커밋

결과: - AI 한계 인정하고 인간에게 명확히 위임 - 인간은 Google Workspace에서 익숙한 방식으로 작업 - 모든 가이드와 커맨드 자동 생성 - 완료 추적 자동화 - 사용자가 모든 기술 체계 중심에서 통제

🎯 핵심 차별화 요소

1. 브라우저 없는 완전 자동화

기존 방식:

사람 타이핑 → 브라우저 열기 → 로그인 → 클릭 클릭 → 복사 붙여넣기

MCP 방식:

AI가 백그라운드 실행 → OAuth 자동 인증 → API 직접 호출 → 완료

2. 리포 = 단일 진실 원천

데이터 정합성:

잘못된 방식:
  - Google Sheets에 버전 A
  - 로컬 파일에 버전 B
  - 메일에 버전 C
  - 어느 것이 최신인지 모름
 
올바른 방식:
  - Git 리포: 버전 A (최신, 커밋 히스토리)
  - Google Sheets: 버전 A (자동 동기화)
  - 메일: 버전 A (자동 생성)
  - 모든 데이터의 원천은 리포

3. 레거시 도구 호환

일반인 협업 가능:

개발자: Git, CLI, Vim 사용
일반인: Google Sheets, Docs, Calendar 사용
↓
AI 에이전트가 양쪽 포맷 자동 변환
↓
모두가 익숙한 도구로 협업 가능

📊 실제 사례

사례 1: SKS Gateway TC 마감 관리

문제: 이번주 TC 완료 마감, 시간 관리 필요

해결 (리포 중심):

# 1. 리포에 프로젝트 상태 기록
~/claude-memory/projects/20251022T111907--sks-gateway-프로젝트__active.org
- 마감: 2025-11-15
- 상태: URGENT
- 남은 작업: TC 작성, 테스트 검증
 
# 2. AI가 Google Calendar에 시간 블록 생성
월: 09:00-12:00 TC 작성
화: 09:00-12:00 TC 작성
수: 14:00-17:00 테스트 검증
 
# 3. 일일 진행률 Google Sheets 자동 업데이트
날짜 | 작업 | 완료율 | 남은시간
-----|------|--------|--------
11-11 | TC 설계 | 30% | 28h
11-12 | TC 구현 | 50% | 20h
 
# 4. 마감 임박시 Google Chat 알림
"⚠️ SKS Gateway TC 마감 3일 남음. 현재 진행률 70%"

사례 2: Anthropic 지원서 준비

문제: 여러 문서 버전 관리, 커밋 ID 검증

해결 (리포 중심):

# 1. 리포에 모든 지원 자료 작성
~/claude-memory/projects/anthropic-korea-application/
- README.md
- SUBMISSION-FIELDS.md
- TODO.org
 
# 2. AI가 커밋 ID 자동 검증
public_repos = ["meta-config", "nixos-config", "doomemacs-config"]
for repo in public_repos:
    latest_commit = git.log("-1 --format=%h %ci")
    update_document(f"verified: {latest_commit}")
 
# 3. Google Docs로 프리뷰 자동 생성
workspace.docs.create(
    title="Anthropic Application Preview",
    content=render_markdown_to_docs(
        "~/claude-memory/projects/anthropic-korea-application/README.md"
    )
)
 
# 4. 제출 전 체크리스트 Gmail 전송
workspace.gmail.send(
    to="user@example.com",
    subject="📋 Anthropic 지원서 최종 체크",
    body=generate_checklist_html()
)

🚀 구현 로드맵

Phase 1: Google Workspace MCP 설정 (1주)

목표: 브라우저 없는 Google Workspace 접근

# 1. Google Cloud 프로젝트 생성
- OAuth 2.0 클라이언트 ID 발급
- API 활성화: Calendar, Gmail, Drive, Sheets, Docs
 
# 2. MCP 서버 설치
uvx workspace-mcp --tool-tier extended
 
# 3. 인증 설정
export GOOGLE_OAUTH_CLIENT_ID="..."
export GOOGLE_OAUTH_CLIENT_SECRET="..."
 
# 4. 테스트
python test_calendar_api.py
python test_gmail_api.py

성공 지표: - [ ] 브라우저 없이 캘린더 이벤트 생성 - [ ] 브라우저 없이 메일 발송 - [ ] 브라우저 없이 시트 업데이트

Phase 2: PM 에이전트 통합 (2주)

목표: 시간 관리 자동화

Features:
  - 프로젝트별 시간 추적 (리포 → Sheets)
  - 가용 시간 계산 (Calendar 분석)
  - 주간 리포트 자동 생성 (Sheets + Gmail)
  - 마감 알림 (Chat 메시지)

성공 지표: - [ ] 주간 가용 시간 자동 계산 - [ ] 프로젝트별 시급 계산 - [ ] 자동 일정 최적화

Phase 3: 여행 에이전트 (2주)

목표: 이메일 → 캘린더 → 드라이브 자동화

Workflow:
  1. Gmail 항공권 메일 감지
  2. AI 파싱 및 정보 추출
  3. Calendar 일정 자동 생성
  4. Drive 티켓 백업
  5. 리포에 여행 기록

성공 지표: - [ ] 항공권 메일 자동 감지 - [ ] 캘린더 일정 자동 생성 - [ ] 드라이브 파일 자동 백업

Phase 4: 채팅 자동 응답 (3주)

목표: Google Chat 질문 자동 답변

Features:
  - 리포 컨텍스트 자동 로드
  - 질문 의도 파악
  - 답변 자동 생성 및 전송
  - 대화 히스토리 리포 저장

성공 지표: - [ ] 팀 질문 80% 자동 응답 - [ ] 응답 정확도 90% 이상 - [ ] 평균 응답 시간 < 1분

📐 아키텍처 통합

meta-config 6-Layer와의 관계

기존 meta-config:
  Layer 1: User Interface (Emacs + ACP)
  Layer 2: Meta Agent (Claude)
  Layer 3: Domain Agents
  Layer 4: memacs Layer (org-mode)  ← 기존 인터페이스
  Layer 5: MCP Tools
  Layer 6: External Services
 
확장 (Google Workspace 통합):
  Layer 4a: memacs Layer (org-mode)     ← 개발자용
  Layer 4b: Workspace Layer (Calendar, Sheets, Docs) ← 일반인용
  ↓
  동일한 리포 데이터를 두 가지 뷰로 제공
  - 개발자: org-mode 파일
  - 일반인: Google Sheets, Docs

데이터 동기화 전략

class RepositoryWorkspaceSync:
    """리포 ↔ Google Workspace 양방향 동기화"""
 
    def sync_to_workspace(self, repo_file, workspace_resource):
        """리포 → Workspace (자동 변환)"""
        data = self.read_repo(repo_file)
        transformed = self.agent.transform(
            data=data,
            target_format=workspace_resource.type
        )
        workspace_resource.update(transformed)
 
    def sync_from_workspace(self, workspace_resource, repo_file):
        """Workspace → 리포 (인간 입력 반영)"""
        data = workspace_resource.read()
        validated = self.agent.validate(data)
 
        if validated.is_safe():
            self.update_repo(repo_file, validated.data)
            self.git.commit(f"Update from {workspace_resource.name}")
        else:
            self.notify_conflict(validated.issues)

🎓 핵심 인사이트

1. “실제 창조물은 리포에”

이유: - 버전 관리 (모든 변경사항 추적) - 협업 가능 (Fork, PR, Review) - 자동화 가능 (CI/CD, Git hooks) - 백업 자동 (GitHub, GitLab)

반례 (레거시 도구의 한계): - Google Docs: 버전 관리 약함 - Email: 검색 어려움, 정리 힘듦 - Excel: 협업 충돌, 데이터 손실

2. “인간이 원하는 포맷으로 변환”

이유: - 일반인은 Git 사용 어려움 - 익숙한 도구가 생산성 높음 - 시각화가 이해도 향상 - 실시간 협업 필요

구현: - AI 에이전트가 자동 변환 - 포맷 선택 가능 (Sheets, Docs, Slides) - 컨텍스트 유지 (히스토리 링크)

3. “레거시 도구 = 로그/버그 데이터”

의미: - Google Workspace 데이터는 부산물 - 실제 데이터는 항상 리포에 - Workspace는 인간 협업용 뷰 - 언제든 리포에서 재생성 가능

장점: - 데이터 정합성 보장 - 자동화 가능 - 히스토리 추적 용이

🔗 관련 문서

20251112T100233--google-workspace-mcp-통합-솔루션__solution_mcp_calendar_pm.md
20251111T182245--meta-config-아키텍처-업데이트__solution_agent_architecture.md
20251111T155842--클로드-코드-웹-pr-워크플로우__workflow_solution_web.md
20250922T115000--pm-에이전트-명세__active_agent_pm.org

📝 결론

이 철학의 완성도:

텍스트 중심 지식관리 (기존)
- org-mode, Markdown, Git
- 개발자 최적화
리포 중심 프로젝트 관리 (기존)
- 코드, 문서, 데이터 통합
- 버전 관리, CI/CD
일반인 협업 모델 (신규, 완성)
- Google Workspace 인터페이스
- 자동 변환 레이어
- 브라우저 없는 자동화

다음 단계: 1. Google Workspace MCP 설정 (이번주) 2. PM 에이전트 캘린더 통합 (1-2주) 3. 실제 프로젝트 적용 및 검증

마지막 업데이트: 2025-11-12T10:11 작성자: Claude + Junghan 상태: 🔥 핵심 철학 완성

Google Workspace MCP 멀티계정 통합 가이드

개요

Google Workspace MCP를 통한 Personal/Work 계정 동시 지원 및 멀티 디바이스 OAuth 인증 워크플로우.

핵심 가치: 에이전트-인간 협업 최적화

에이전트 관점

✅ 완벽한 정보 제공: 계정별 명확한 데이터 접근
✅ 토큰 절약: 인증 정보 명확 → 재질문 불필요
✅ 컨텍스트 유지: Personal/Work 데이터 혼재 없음

인간 관점

✅ 시간 절약: 브라우저 인증 1회로 지속 사용
✅ 통합 경험: 하나의 에이전트로 양쪽 계정 관리
✅ 디바이스 유연성: 어디서나 동일한 워크플로우

계정 분리 구조

Personal/Work 완전 분리

┌─────────────────────────────────────────────────────┐
│              Google Workspace MCP                   │
├─────────────────────┬───────────────────────────────┤
│   Personal Account  │      Work Account             │
├─────────────────────┼───────────────────────────────┤
│ OAuth Port: 28000   │ OAuth Port: 28001             │
│ Credentials Dir:    │ Credentials Dir:              │
│  ~/.google_         │  ~/.google_workspace_mcp_work │
│   workspace_mcp/    │   /credentials/               │
│   credentials/      │                               │
├─────────────────────┼───────────────────────────────┤
│ 데이터:             │ 데이터:                       │
│ - 개인 Gmail        │ - 업무 Gmail                  │
│ - 개인 Calendar     │ - 업무 Calendar               │
│ - 개인 Drive        │ - 업무 Drive/Sheets           │
│ - 개인 Tasks        │ - 팀 협업 문서                │
└─────────────────────┴───────────────────────────────┘

MCP 서버 설정 (`~/.mcp.json`)

{
  "mcpServers": {
    "google-workspace-personal": {
      "command": "~/claude-config/mcp-wrappers/google-workspace-mcp-wrapper-personal.sh",
      "args": []
    },
    "google-workspace-work": {
      "command": "~/claude-config/mcp-wrappers/google-workspace-mcp-wrapper-work.sh",
      "args": []
    }
  }
}

Wrapper 스크립트 구조

Personal (google-workspace-mcp-wrapper-personal.sh):

#!/usr/bin/env bash
 
export GOOGLE_OAUTH_CLIENT_ID="[Personal OAuth Client ID]"
export GOOGLE_OAUTH_CLIENT_SECRET="[Personal OAuth Client Secret]"
export USER_GOOGLE_EMAIL="[personal-email@example.com]"
export WORKSPACE_MCP_PORT=28000
export GOOGLE_OAUTH_REDIRECT_URI="http://localhost:28000/oauth2callback"
 
exec uvx workspace-mcp --tool-tier core --single-user

Work (google-workspace-mcp-wrapper-work.sh):

#!/usr/bin/env bash
 
export GOOGLE_OAUTH_CLIENT_ID="[Work OAuth Client ID]"
export GOOGLE_OAUTH_CLIENT_SECRET="[Work OAuth Client Secret]"
export USER_GOOGLE_EMAIL="[work-email@company.com]"
export WORKSPACE_MCP_PORT=28001
export GOOGLE_OAUTH_REDIRECT_URI="http://localhost:28001/oauth2callback"
 
# Work 전용 credentials 디렉토리
export GOOGLE_MCP_CREDENTIALS_DIR="$HOME/.google_workspace_mcp_work/credentials"
 
exec uvx workspace-mcp --tool-tier core --single-user

OAuth 인증 메커니즘

로컬 디바이스 (브라우저 직접 접근)

1. Claude에서 MCP 툴 호출
   ↓
2. MCP 서버 자동 시작 (포트 28000 또는 28001)
   ↓
3. OAuth URL 생성
   ↓
4. 로컬 브라우저에서 직접 열기
   ↓
5. Google 계정 인증
   ↓
6. Callback → localhost:2800X/oauth2callback
   ↓
7. Credentials 저장

원격 디바이스 (SSH 포트 포워딩)

[외부 노트북]                    [원격 서버]
     ↓                                ↓
  브라우저 ←─── SSH 터널 ────→ MCP 서버 (포트 28000)
     ↓                                ↓
  localhost:28000 ────────────→ OAuth Callback
     ↓                                ↓
  Google 인증 ─────────────────→ Credentials 저장

SSH 포트 포워딩 명령:

# 기본 형식
ssh -L 28000:localhost:28000 user@remote-server
 
# Personal 계정용
ssh -L 28000:localhost:28000 user@server
 
# Work 계정용 (포트 28001)
ssh -L 28001:localhost:28001 user@server

멀티 디바이스 OAuth 인증 프로세스

브라우저 인증 vs 텍스트 링크 방식

기존 방식 (비효율):

에이전트가 OAuth 정보 불완전하게 파악
인간이 문서/설정 찾아다니며 시간 소모
재질문으로 토큰 낭비

개선 방식 (효율):

OAuth 링크를 텍스트 파일로 저장
브라우저에서 직접 인증 처리
에이전트는 완벽한 정보로 즉시 작업

디바이스별 인증 전략

로컬 디바이스 (Ubuntu Laptop):

# 1. Claude 실행
claude
 
# 2. MCP 툴 호출 (자동으로 OAuth 서버 시작)
"Personal Gmail 읽어줘"
 
# 3. 브라우저에서 인증 링크 열기
# localhost:28000 자동 접근

원격 디바이스 (NixOS Servers):

# 1. SSH 포트 포워딩으로 접속
ssh -L 28000:localhost:28000 user@server
 
# 2. Claude 실행
claude
 
# 3. OAuth 링크 텍스트 파일 확인
cat ~/google-workspace-personal-oauth-link.txt
 
# 4. 로컬 노트북 브라우저에서 링크 열기
# SSH 터널 통해 원격 서버로 전달

모바일 디바이스 (Termux):

# 방법 1: Termux 브라우저 앱
termux-open-url "[OAuth URL]"
 
# 방법 2: Syncthing 활용
# 1. SSH 세션에서 OAuth 링크 파일 생성
# 2. Syncthing으로 자동 동기화
# 3. 노트북 브라우저에서 열기

MCP 서버 리소스 관리

현재 구조의 문제점

Claude 실행마다 MCP 서버 재생성:

Claude 시작 → 6개 MCP 서버 프로세스 생성 (Personal + Work 포함)
             → 메모리: ~500MB
             → 초기화 시간: 3-5초
 
Claude 종료 → 모든 MCP 서버 종료
             → 다음 실행 시 재생성 필요

비효율성:

매번 서버 초기화 오버헤드
메모리 중복 사용
인증 상태는 유지되지만 서버는 재시작

향후 개선 방향

지속적 MCP 인스턴스 (단일 서버):

┌─────────────────────────────────────────┐
│     Persistent MCP Server Instance      │
│     (Background Service)                │
├─────────────────────────────────────────┤
│ ✓ 시스템 시작 시 1회 실행               │
│ ✓ 모든 Claude 세션이 공유 사용          │
│ ✓ 메모리 효율: 500MB → 150MB 절감       │
│ ✓ 초기화 불필요: 즉시 응답              │
└─────────────────────────────────────────┘

구현 계획:

MCP 서버를 systemd 서비스로 등록
Unix socket 통신으로 Claude 연결
세션별 인증 토큰 캐싱
필요시에만 서버 재시작

실전 워크플로우

시나리오 1: 개인 Gmail 확인 (로컬)

상황: 노트북에서 개인 이메일 확인
 
1. Claude 실행
2. "Personal Gmail 최근 5개 읽어줘"
3. 첫 실행 → 브라우저 인증 (1회만)
4. 이후 자동으로 토큰 재사용

시나리오 2: 업무 캘린더 확인 (원격)

상황: 원격 서버에서 업무 일정 확인
 
1. 노트북에서 SSH 포트 포워딩 접속
   ssh -L 28001:localhost:28001 user@server
 
2. 원격 서버에서 Claude 실행
 
3. "Work Calendar 오늘 일정 보여줘"
 
4. OAuth 링크 텍스트 파일 확인
   cat ~/google-workspace-work-oauth-link.txt
 
5. 노트북 브라우저에서 링크 열어 Work 계정 인증
 
6. 이후 자동 사용

시나리오 3: Personal/Work 동시 사용

상황: 개인 Tasks와 업무 Sheets 동시 확인
 
1. "Personal Tasks 목록 보여줘"
   → Personal MCP (포트 28000) 사용
 
2. "Work Sheets에서 개발팀 카드 읽어줘"
   → Work MCP (포트 28001) 사용
 
✓ 완전 분리: 데이터 혼재 없음
✓ 동시 실행: 두 서버 독립적으로 작동

SSH Config 자동화

포트 포워딩 자동 설정

~/.ssh/config:

# Personal 계정용 (포트 28000)
Host server-personal
  HostName 192.168.1.100
  User username
  LocalForward 28000 localhost:28000
 
# Work 계정용 (포트 28001)
Host server-work
  HostName 192.168.1.100
  User username
  LocalForward 28001 localhost:28001
 
# 둘 다 포워딩
Host server-both
  HostName 192.168.1.100
  User username
  LocalForward 28000 localhost:28000
  LocalForward 28001 localhost:28001

사용:

# Personal만
ssh server-personal
 
# Work만
ssh server-work
 
# 둘 다
ssh server-both

Troubleshooting

Port already in use

# 프로세스 확인
lsof -ti:28000
lsof -ti:28001
 
# 종료
kill $(lsof -ti:28000)
kill $(lsof -ti:28001)

Personal/Work 데이터 혼재

원인: Credentials 디렉토리 미분리

확인:

# Personal credentials
ls ~/.google_workspace_mcp/credentials/
 
# Work credentials
ls ~/.google_workspace_mcp_work/credentials/

해결:

Work wrapper 스크립트에 GOOGLE_MCP_CREDENTIALS_DIR 설정 확인
Claude 재시작
Work MCP 재인증

OAuth 인증 후에도 계속 요청

원인: State 파라미터 불일치

해결:

Personal URL을 Work에 사용 금지
각 서버가 생성한 실제 OAuth URL 사용
텍스트 파일의 링크는 참고용 (state 값 다름)

체크리스트

초기 설정

Google Cloud Console OAuth Client 생성 (Personal/Work)
MCP Wrapper 스크립트 작성
~/.mcp.json 설정
SSH Config 포트 포워딩 설정 (원격 사용 시)

계정별 인증

Personal 첫 OAuth 인증 (포트 28000)
Work 첫 OAuth 인증 (포트 28001)
Credentials 파일 생성 확인
Personal/Work 데이터 분리 검증

일상 사용

SSH 포트 포워딩 접속 (원격 시)
Claude 실행
Personal/Work MCP 툴 선택적 사용
토큰 자동 재사용 확인

향후 개선 계획

1단계: 현재 구조 최적화

Personal/Work 완전 분리
OAuth 텍스트 파일 자동화
Syncthing 통한 멀티 디바이스 동기화

2단계: 지속적 MCP 인스턴스

MCP 서버 systemd 서비스화
Unix socket 통신 구현
세션별 토큰 캐싱
리소스 모니터링 대시보드

3단계: 멀티테넌트 지원

단일 MCP 서버에서 Personal/Work 통합
동적 계정 전환
토큰 풀링 최적화

참고 자료

Google Workspace MCP: https://github.com/taylorwilsdon/google_workspace_mcp
SSH Tunneling: https://www.ssh.com/academy/ssh/tunneling
OAuth 2.0: https://developers.google.com/identity/protocols/oauth2

메타데이터

작성일: 2025-11-14
최종 업데이트: 2025-11-14 12:30 (Google Chat + Apps Script 통합 완료)
기반 문서: 20251113T202100—google-workspace-mcp-멀티디바이스-oauth-가이드
검증 환경: Ubuntu 24.04 (LAPTOP)
상태: Active Workflow

Google Chat + Apps Script 통합: 에이전트의 날개

🎯 핵심 발견: 토큰 효율적 에이전트 확장

문제 정의

Claude 에이전트의 근본적 한계:

기존 방식 (비효율):
  Claude → MCP → Google API → 데이터 가져오기 (5,000 토큰)
         ↓
  Claude가 데이터 처리 (10,000 토큰)
         ↓
  Claude → MCP → Google API → 결과 쓰기 (2,000 토큰)
 
  총 토큰: 17,000 토큰
  시간: 느림 (여러 API 왕복)
  Claude 부하: 높음

해결책: Apps Script 내부 처리

Apps Script 방식 (효율):

Claude → MCP → Apps Script 트리거 (200 토큰)
                     ↓
              [Apps Script 내부 실행]
              - Calendar 읽기
              - Gmail 검색
              - 데이터 집계
              - Sheets 업데이트
                     ↓
Claude ← MCP ← 결과만 리턴 (300 토큰)
 
총 토큰: 500 토큰 (34배 절감!)
시간: 빠름 (Google 내부 처리)
Claude 부하: 낮음 (명령만)

🚀 2025-11-14 통합 완료

달성 사항

오늘 순식간에 해결된 것들:

✅ Apps Script 프로젝트 생성
✅ Chat App 최소 구성 (함수 5개)
✅ Web App 배포 (Deployment ID 확보)
✅ Google Cloud Console Chat API 설정
✅ Work 계정 Chat MCP 완전 작동

검증 완료:

Chat 메시지 전송: ✅
Chat 메시지 읽기: ✅
Space 식별: ✅
Apps Script 트리거 구조: ✅

🎨 Apps Script의 강력한 확장성

IDE 통합과 같은 개념

“Google Workspace에 Apps Script를 연결하는 것은 Claude에 IDE를 통합하는 것과 같다.

IDE가 코드 편집, 디버깅, 빌드를 내부에서 처리하듯, Apps Script는 Workspace 데이터 처리를 내부에서 완결한다.”

Apps Script가 제공하는 것

1. Bound Scripts (파일 내장 로직):

// Sheets에 직접 연결
function onOpen() {
  SpreadsheetApp.getUi()
    .createMenu('Claude 자동화')
    .addItem('주간 리포트', 'generateReport')
    .addToUi();
}
 
// 사용자가 메뉴 클릭 → Apps Script 실행 → 결과 즉시 반영

2. Custom Functions (셀 함수):

// Sheets 셀에서 =CLAUDE_ANALYZE(A1:A10) 처럼 사용
function CLAUDE_ANALYZE(range) {
  var data = range.getValues();
  // 내부 처리 (토큰 절약)
  var summary = processData(data);
  return summary;
}

3. Time-driven Triggers (자동 실행):

// 매일 9시 자동 실행 (브라우저/Claude 없이도!)
function dailyReport() {
  var events = CalendarApp.getEventsForWeek(new Date());
  var sheet = SpreadsheetApp.openById('...');
 
  // 데이터 집계 및 저장
  sheet.appendRow([new Date(), events.length]);
 
  // Gmail 리포트 발송
  GmailApp.sendEmail('user@example.com', '일일 리포트', ...);
}

4. Web App Endpoints (MCP 트리거):

// MCP에서 HTTP로 호출 가능
function doGet(e) {
  var action = e.parameter.action;
 
  switch(action) {
    case 'weekly_report':
      return generateWeeklyReport();
    case 'analyze_time':
      return analyzeProjectTime();
  }
}
 
// MCP에서:
// requests.get('https://script.google.com/macros/s/[ID]/exec?action=weekly_report')

💡 Apps Script vs GCP: 명확한 차이

측면	Apps Script	GCP (Cloud Functions/Run)
설정 복잡도	⭐ 매우 간단	⭐⭐⭐⭐ 복잡
배포 시간	1분	5-10분
비용	무료 (쿼터 내)	유료 (실행시간 기준)
Workspace 통합	✅ 네이티브	⚠️ API만
Custom Functions	✅ Sheets에서 직접 사용	❌ 불가능
Triggers	✅ Time/Event-driven	⚠️ Pub/Sub 필요
인증	자동 (Workspace 내부)	OAuth 설정 필요
확장성	중간 (6분 실행 제한)	높음 (무제한)

권장 사용

Apps Script 사용:

Workspace 데이터 집약 작업 (Calendar, Sheets, Gmail)
주기적 리포트 자동화
Custom functions (Sheets)
간단한 워크플로우

GCP 사용:

장시간 실행 필요 (6분+ )
외부 API 많이 호출
복잡한 ML/AI 처리
대용량 데이터 처리

🎯 실전 활용: 토큰 효율화 시나리오

시나리오 1: 주간 프로젝트 리포트

기존 방식 (MCP만):

# 토큰: ~15,000
events = mcp.calendar.get_events(days=7)  # 3,000 토큰
emails = mcp.gmail.search('project:sks')  # 5,000 토큰
# Claude가 데이터 분석                    # 5,000 토큰
mcp.sheets.update(report_data)            # 2,000 토큰

Apps Script 방식:

// Apps Script에서 모두 처리
function weeklyProjectReport() {
  // 1. Calendar 데이터 (Google 내부)
  var cal = CalendarApp.getCalendarById('work@example.com');
  var events = cal.getEventsForWeek(new Date());
 
  // 2. Gmail 데이터 (Google 내부)
  var threads = GmailApp.search('project:sks newer_than:7d');
 
  // 3. 집계 (Google 내부)
  var report = {
    meetings: events.length,
    emails: threads.length,
    hours: calculateHours(events)
  };
 
  // 4. Sheets 업데이트 (Google 내부)
  var sheet = SpreadsheetApp.openById('...');
  sheet.appendRow([new Date(), report.meetings, report.emails, report.hours]);
 
  // 5. 결과만 리턴
  return report;
}

# Claude/MCP에서
result = call_apps_script('weeklyProjectReport')  # 500 토큰!
print(f"리포트 생성 완료: {result}")

효과:

토큰: 15,000 → 500 (30배 절감)
속도: Google 내부 실행으로 빠름
신뢰도: 데이터 전송 오류 없음

시나리오 2: PM 에이전트 - 할일 자동 생성

Apps Script로 처리:

function createTasksFromIssues() {
  // GitHub Issues → Google Tasks 자동 변환
  // (MCP가 GitHub 데이터 전달, Apps Script가 Tasks 생성)
 
  var tasks = TasksApp.getDefaultTaskList();
 
  issues.forEach(function(issue) {
    tasks.newTask()
      .setTitle('[' + issue.repo + '] ' + issue.title)
      .setNotes(issue.body)
      .setDue(issue.due_date)
      .create();
  });
 
  return {created: issues.length};
}

MCP에서:

# 1. GitHub에서 이슈 가져오기 (MCP)
issues = mcp.github.get_issues(repo='sks-gateway', state='open')
 
# 2. Apps Script로 전달 (POST)
result = call_apps_script('createTasksFromIssues', data={'issues': issues})
 
# 토큰: 이슈 목록만 (2,000 토큰)
# vs 기존: 이슈 + Tasks CRUD 반복 (8,000 토큰)

시나리오 3: 협업 - 팀 리포트 자동 생성

Apps Script Time-driven:

// 매주 금요일 17시 자동 실행 (사람 개입 불필요!)
function fridayTeamReport() {
  // 1. 이번 주 팀 캘린더 미팅
  var cal = CalendarApp.getCalendarById('team@company.com');
  var meetings = cal.getEventsForWeek(new Date());
 
  // 2. 이번 주 팀 Gmail (중요한 것만)
  var important = GmailApp.search('to:team@company.com is:important newer_than:7d');
 
  // 3. Google Docs 리포트 자동 생성
  var doc = DocumentApp.create('주간 팀 리포트 ' + new Date());
  var body = doc.getBody();
  body.appendParagraph('이번 주 미팅: ' + meetings.length + '건');
  body.appendParagraph('중요 이메일: ' + important.length + '건');
 
  // 4. 팀 Chat에 자동 공유
  // (Chat API 호출)
 
  // 5. Sheets에 히스토리 기록
  var sheet = SpreadsheetApp.openById('team-dashboard');
  sheet.appendRow([new Date(), meetings.length, important.length, doc.getUrl()]);
 
  return {
    doc_url: doc.getUrl(),
    meetings: meetings.length,
    emails: important.length
  };
}
 
// 트리거 설정 (1회만 실행)
function setupFridayTrigger() {
  ScriptApp.newTrigger('fridayTeamReport')
    .timeBased()
    .onWeekDay(ScriptApp.WeekDay.FRIDAY)
    .atHour(17)
    .create();
}

효과:

사람 개입: 0 (완전 자동)
Claude 개입: 0 (자동 실행)
토큰 소모: 0 (실행 시)
리포트 생성: 매주 금요일 자동

🏗️ 아키텍처 확장: Apps Script Layer

기존 6-Layer + Apps Script (7-Layer)

┌─────────────────────────────────────────┐
│ 1. User Interface (Emacs + ACP)         │
└─────────────────────────────────────────┘
              ↓ ↑
┌─────────────────────────────────────────┐
│ 2. Meta Agent (Claude - Orchestration)  │
└─────────────────────────────────────────┘
              ↓ ↑
┌─────────────────────────────────────────┐
│ 3. Domain Agents                        │
└─────────────────────────────────────────┘
              ↓ ↑
┌─────────────────────────────────────────┐
│ 4. memacs Layer (org-mode)              │
└─────────────────────────────────────────┘
              ↓ ↑
┌─────────────────────────────────────────┐
│ 5. MCP Tools                            │
└─────────────────────────────────────────┘
              ↓ ↑
┌─────────────────────────────────────────┐
│ 6. Apps Script Layer (NEW!)             │  ← 🆕
│    - Workspace 내부 자동화              │
│    - 토큰 효율적 데이터 처리            │
│    - Time-driven 완전 자동화            │
└─────────────────────────────────────────┘
              ↓ ↑
┌─────────────────────────────────────────┐
│ 7. External Services (Google Workspace) │
└─────────────────────────────────────────┘

Apps Script Layer의 역할

토큰 효율화:

Google 서비스 간 데이터 이동을 내부에서 처리
Claude는 명령만 보내고 결과만 받음
대용량 데이터를 Claude가 볼 필요 없음

완전 자동화:

Time-driven triggers로 사람/Claude 없이도 실행
주기적 리포트, 데이터 백업, 알림 발송

확장 가능:

Custom functions로 Sheets를 강력하게
Bound scripts로 각 문서에 로직 내장
Web App으로 MCP와 양방향 통신

💼 협업 관점: PM 에이전트의 날개

Google Tasks + Sheets + Chat 통합

PM 워크플로우 자동화:

// Apps Script: PM 자동화
function pmAgentWorkflow() {
  // 1. GitHub Issues → Google Tasks
  var issues = getGitHubIssues();  // MCP가 전달
  var taskList = TasksApp.getDefaultTaskList();
 
  issues.forEach(function(issue) {
    taskList.newTask()
      .setTitle('[' + issue.label + '] ' + issue.title)
      .setDue(issue.due_date)
      .create();
  });
 
  // 2. Calendar 분석 → 가용 시간 계산
  var cal = CalendarApp.getDefaultCalendar();
  var events = cal.getEventsForWeek(new Date());
  var busyHours = calculateBusyTime(events);
  var availableHours = 40 - busyHours;  // 주 40시간 기준
 
  // 3. Sheets에 자동 기록
  var sheet = SpreadsheetApp.openById('pm-dashboard');
  sheet.appendRow([
    new Date(),
    issues.length,
    busyHours,
    availableHours,
    availableHours * hourlyRate  // 수익 추정
  ]);
 
  // 4. 경고: 가용 시간 부족 시 Chat 알림
  if (availableHours < 10) {
    sendChatMessage('team-space',
      '⚠️ 이번 주 가용 시간: ' + availableHours + '시간만 남음!');
  }
 
  return {
    tasks_created: issues.length,
    available_hours: availableHours
  };
}

Claude의 역할:

# 간단한 트리거만
result = mcp.apps_script.call('pmAgentWorkflow')
 
# 응답
"PM 워크플로우 완료:
 - Tasks 생성: 5개
 - 가용 시간: 12시간
 - 예상 수익: 600,000원"
 
# 토큰: ~500 (vs 기존 15,000)

협업 시나리오: 문서 자동 생성

주간 미팅 노트 자동화:

// Calendar 이벤트 기반 자동 실행
function onMeetingEnd(event) {
  // 1. 미팅 정보 수집
  var meeting = event.calendarEvent;
  var attendees = meeting.getGuestList();
 
  // 2. Google Docs 미팅 노트 자동 생성
  var doc = DocumentApp.create('미팅노트: ' + meeting.getTitle());
  var body = doc.getBody();
 
  body.appendParagraph('일시: ' + meeting.getStartTime());
  body.appendParagraph('참석자: ' + attendees.map(g => g.getEmail()).join(', '));
  body.appendParagraph('\n## 논의 사항\n- \n\n## 액션 아이템\n- [ ] ');
 
  // 3. 참석자에게 Gmail 발송
  GmailApp.sendEmail(
    attendees.map(g => g.getEmail()).join(','),
    '[미팅노트] ' + meeting.getTitle(),
    '미팅 노트가 생성되었습니다: ' + doc.getUrl()
  );
 
  // 4. Drive 폴더에 정리
  DriveApp.getFileById(doc.getId())
    .moveTo(DriveApp.getFolderById('meeting-notes-folder'));
 
  // 5. Chat에 공유
  sendChatMessage('team-space',
    '📝 미팅 노트: ' + doc.getUrl());
}

효과:

미팅 끝나면 자동으로 노트 템플릿 생성
참석자에게 자동 공유
Drive 정리 자동
Chat 알림 자동
사람이 할 일: 내용만 채우기

🚀 향후 확장 계획

Phase 1: 기본 자동화 (현재 완료)

Chat App 구성
Apps Script 배포
MCP 통신 검증
메시지 송수신 성공

Phase 2: 토큰 효율화 (1-2주)

주간 리포트 Apps Script 작성
MCP → Apps Script 트리거 구현
Custom functions 개발 (Sheets)
Time-driven triggers 설정

Phase 3: 완전 자동화 (1개월)

PM 워크플로우 자동화
- GitHub Issues → Tasks
- Calendar 분석 → 가용 시간
- Sheets 자동 업데이트
- Chat 알림 자동 발송
협업 워크플로우 자동화
- 미팅 노트 자동 생성
- 리포트 자동 발송
- 문서 자동 정리

Phase 4: AI 통합 (2-3개월)

Apps Script에서 Claude API 호출
양방향 통신
- Apps Script → Claude (분석 요청)
- Claude → Apps Script (자동화 트리거)
완전 자율 에이전트 시스템

📊 성과 지표

토큰 효율성

작업	기존 MCP	Apps Script	절감률
주간 리포트	15,000	500	96%
Tasks 생성	8,000	300	96%
데이터 집계	10,000	400	96%
미팅 노트	12,000	600	95%

자동화 수준

기존 (MCP만):

사람 트리거: 100%
Claude 개입: 100%
자동 실행: 0%

Apps Script 통합 후:

사람 트리거: 20% (최종 검토만)
Claude 개입: 30% (명령만)
자동 실행: 50% (Time-driven)

🎓 핵심 인사이트

“Apps Script는 Google Workspace 안에 에이전트의 분신을 두는 것이다.

Claude가 매번 Workspace를 방문하는 대신, Apps Script가 상주하며 24시간 데이터를 관리한다.

이는 IDE가 개발자를 돕듯, Workspace가 에이전트를 돕는 구조다.”

왜 효과적인가?

1. 데이터 지역성 (Data Locality):

데이터가 생성/소비되는 곳에서 처리
Google 내부에서 완결
네트워크 왕복 최소화

2. 간단한 설정:

GCP 복잡한 설정 불필요
OAuth 자동 처리
5분이면 배포 완료

3. 안정성:

Google의 인프라 활용
99.9% 가용성
자동 스케일링

4. 협업 친화적:

팀원들이 익숙한 도구 (Sheets, Docs, Chat)
실시간 협업
권한 관리 용이

🔗 Apps Script 리소스

공식 문서:

Apps Script 가이드: https://developers.google.com/apps-script
Chat API: https://developers.google.com/chat
Workspace Services: https://developers.google.com/apps-script/reference

생성된 리소스:

Apps Script Project ID: `[APPS_SCRIPT_PROJECT_ID]`
Deployment ID: `[DEPLOYMENT_ID]`
Chat App: MCP Chat App

🎯 결론

Google Workspace MCP + Apps Script 통합은:

토큰 효율화: 평균 30배 절감
완전 자동화: Time-driven triggers
간단한 설정: 5분이면 배포
협업 강화: 팀원들이 익숙한 도구
에이전트 확장: IDE처럼 Workspace 내장 로직

다음 단계:

PM 워크플로우 Apps Script 작성
Custom functions 개발
Time-driven 자동화 설정
실제 프로젝트 적용 및 검증

메타:

2025-11-14 순식간에 해결된 문제들
Apps Script = 에이전트에 날개를 달아준 것
토큰 효율 + 완전 자동화의 완벽한 조합

junghanacs🧠

Table of Contents

Backlinks

@힣: #워크스페이스 #에이전트 #서비스 #통합

히스토리

meta-config 아키텍처 업데이트

🎯 핵심 발견: Claude Web의 강력한 기능

📊 meta-config 최신 현황 (2025-11-11)

Version

최근 주요 커밋 (Nov 11)

🏗️ 6-Layer 아키텍처 (최신)

🆕 memacs Layer (핵심 혁신)

문제 정의

memacs 솔루션

🔄 3-Protocol 체계

1. ACP (Agent Client Protocol)

2. A2A (Agent-to-Agent)

3. MCP (Model Context Protocol)

💡 핵심 철학

”Agents All the Way Down”

Separation of Concerns

Context Isolation

🛠️ 개발 가이드라인 (NixOS 특화)

1. Python 프로젝트

2. Bash 스크립팅

3. 문서화

4. 디바이스 컨텍스트

🚀 로드맵

Phase 1: Q4 2025 (진행 중)

Phase 2: Q1 2026

Phase 3: Q2 2026

Phase 4: Q3+ 2026

📂 Repository 구조

🔗 claude-config 연관성

meta-config vs claude-config

통합 방안

💡 claude-config에 적용할 개념

1. memacs Layer 도입

2. Context Isolation

3. 프로토콜 표준화

✅ 즉시 적용 가능한 것

1. CLAUDE.md 개선

2. NixOS 가이드라인 강화

3. 디바이스 컨텍스트

🎯 제안: claude-config 업데이트

Option 1: CLAUDE.md 개선 (즉시)

Option 2: 아키텍처 문서 추가 (단기)

Option 3: 리팩토링 (장기)

📚 참고 링크

🔮 다음 단계

즉시 가능

단기 (1-2주)

장기 (1-3개월)

Google Workspace MCP 통합 솔루션

🎯 핵심 발견: 모든 퍼즐의 마지막 조각

📊 Google Workspace MCP 서버란?

개요

지원 서비스 (완전 통합)

핵심 특징

🚀 힣’s 유스케이스: 완벽한 매칭

1. PM 에이전트 - 캘린더 통합 (🔥 최우선)

2. 여행 에이전트

3. 협업 문서화 & 채팅

4. 메모리 시스템 연동

🛠️ 설치 및 설정

Step 1: Google Cloud 프로젝트 설정

Step 2: MCP 서버 설치

Step 3: Claude Code 통합

💡 실전 시나리오

시나리오 1: PM 에이전트 - 주간 리포트 자동 생성

시나리오 2: 여행 에이전트 - 하와이 여행 자동 관리

시나리오 3: 메모리 시스템 ↔ Drive 동기화

🎯 힣’s 우선순위 적용

Phase 1: PM 에이전트 캘린더 통합 (이번주)

Phase 2: 여행 에이전트 (1-2주)

Phase 3: 전체 통합 (1개월)

🔧 기술 스택 통합

현재 환경

Google Workspace MCP 추가

NixOS 환경 설정

MCP 서버 설정 (`~/.mcp.json`)