Anki와 Claude 연동 완벽 가이드: MCP 연결 및 Python 자동화

소개

이 가이드에서는 Anki(인기 있는 플래시카드 앱)와 Claude AI를 연결하는 두 가지 방법을 알아보겠습니다:

1. MCP(model context protocol)를 통한 직접 연결 - Claude가 직접 Anki를 제어

2. Python 스크립트를 활용한 간접 연결 - Claude가 생성한 코드로 Anki 제어

이 가이드를 통해 다음과 같은 이점을 얻을 수 있습니다:

• AI의 도움을 받아 효율적으로 학습 자료 관리

• 자동화된 카드 생성 및 관리

• 복잡한 학습 컨텐츠의 편리한 처리

필요한 도구 및 사전 요구 사항

• Anki: 최신 버전 설치 (다운로드 링크)

• Anki-Connect: Anki 플러그인 (코드: 2055492159)

• Node.js: anki-mcp-server를 위해 필요 (다운로드 링크)

• Python 3: 스크립트 실행을 위해 필요

• Claude Desktop: Claude AI의 데스크톱 앱

• 텍스트 에디터: 코드 편집을 위해 필요

1단계: Anki 및 Anki-Connect 설정

Anki 설치하기

1. 공식 Anki 웹사이트에서 운영체제에 맞는 버전을 다운로드합니다.

2. 설치 과정을 완료하고 Anki를 실행합니다.

Anki-Connect 플러그인 설치하기

1. Anki를 실행하고 상단 메뉴에서 도구 > 애드온 > 애드온 받기를 선택합니다.

2. 코드 입력 칸에 2055492159를 입력하고 'OK' 버튼을 클릭합니다.

3. Anki를 재시작하라는 메시지가 나타나면 재시작합니다.

Anki-Connect 설정 확인하기

1. Anki를 재시작한 후, 도구 > 애드온 > Anki-Connect > 구성을 선택합니다.

2. 다음과 같이 설정을 수정합니다:

{
  "apiKey": null,
  "apiLogPath": null,
  "ignoreOriginList": [],
  "webBindAddress": "127.0.0.1",
  "webBindPort": 8765,
  "webCorsOriginList": [
    "http://localhost",
    "mcp://*"
  ]
}

3. 'OK' 버튼을 클릭하고 Anki를 다시 재시작합니다.

Anki-Connect 작동 확인하기

1. Anki가 실행 중인 상태에서 웹 브라우저를 열고 http://localhost:8765에 접속합니다.

2. {"apiVersion": "AnkiConnect v.6"} 또는 유사한 메시지가 표시되면 Anki-Connect가 정상적으로 실행 중인 것입니다.

2단계: anki-mcp-server 설치 및 설정

GitHub 저장소 클론하기

터미널(맥/리눅스) 또는 명령 프롬프트(윈도우)를 열고 다음 명령을 실행합니다:

# 적절한 디렉토리로 이동
cd ~/Projects

# 저장소 클론하기
git clone https://github.com/scorzeth/anki-mcp-server.git

# 클론한 디렉토리로 이동
cd anki-mcp-server

의존성 설치 및 서버 빌드하기

# 필요한 패키지 설치
npm install

# 서버 빌드
npm run build

설치 경로 확인하기

다음 명령어를 실행하여 anki-mcp-server의 전체 경로를 확인합니다:

# macOS/Linux
pwd

# Windows
cd

이 경로를 메모해두세요. Claude Desktop 구성 파일에 필요합니다. (예: /Users/username/Projects/anki-mcp-server)

3단계: Claude Desktop 구성

구성 파일 위치 찾기

구성 파일은 운영체제에 따라 다른 위치에 있습니다:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

• Windows: %APPDATA%/Claude/claude_desktop_config.json

구성 파일 수정하기

구성 파일을 열고(없다면 새로 만들고) 다음 내용을 추가합니다:

{
  "mcpServers": {
    "anki-mcp-server": {
      "command": "/전체/경로/anki-mcp-server/build/index.js"
    }
  }
}

/전체/경로 부분을 앞서 확인한 실제 경로로 바꿔주세요.

예를 들어:

{
  "mcpServers": {
    "anki-mcp-server": {
      "command": "/Users/username/Projects/anki-mcp-server/build/index.js"
    }
  }
}

권한 설정 (macOS/Linux만 해당)

터미널에서 다음 명령어를 실행하여 실행 권한을 부여합니다:

chmod +x /전체/경로/anki-mcp-server/build/index.js

4단계: Python 스크립트 작성하기

이제 Python을 사용하여 Anki-Connect API와 통신하는 스크립트를 작성해보겠습니다.

기본 연결 스크립트 만들기

원하는 디렉토리에 anki_connect_tool.py 파일을 만들고 다음 코드를 작성합니다:

import json
import urllib.request

def request_anki(action, **params):
    """Anki-Connect API에 요청을 보내는 기본 함수"""
    request_data = json.dumps({
        'action': action,
        'params': params,
        'version': 6
    }).encode('utf-8')
    
    try:
        response = json.load(urllib.request.urlopen(
            urllib.request.Request('http://localhost:8765', request_data)
        ))
        
        if response['error'] is not None:
            raise Exception(response['error'])
            
        return response['result']
    except Exception as e:
        print(f"오류 발생: {e}")
        return None

# --- 덱 관련 함수 ---

def get_deck_names():
    """모든 덱 이름 목록 가져오기"""
    return request_anki('deckNames')

def create_deck(deck_name):
    """새 덱 생성하기"""
    return request_anki('createDeck', deck=deck_name)

# --- 카드/노트 관련 함수 ---

def add_note(deck_name, front, back, tags=None, model_name="Basic"):
    """
    기본 모델을 사용하여 노트 추가하기
    
    참고: 한글 Anki에서는 model_name을 "기본"으로, 
    fields 키를 "앞면"/"뒷면"으로 바꿔야 할 수 있음
    """
    if tags is None:
        tags = []
    
    fields = {
        "Front": front,  # 한글 Anki: "앞면"
        "Back": back     # 한글 Anki: "뒷면"
    }
    
    return request_anki('addNote', note={
        'deckName': deck_name,
        'modelName': model_name,
        'fields': fields,
        'tags': tags
    })

def find_notes(query):
    """검색 쿼리로 노트 찾기"""
    return request_anki('findNotes', query=query)

def get_notes_info(note_ids):
    """노트 ID 목록으로 노트 정보 가져오기"""
    return request_anki('notesInfo', notes=note_ids)

# --- 테스트 코드 ---

if __name__ == "__main__":
    # Anki 실행 중인지 확인
    try:
        # 덱 목록 출력
        decks = get_deck_names()
        print("덱 목록:", decks)
        
        # 새 덱 만들기
        deck_name = "Python으로_만든_덱"
        create_deck(deck_name)
        print(f"새 덱 '{deck_name}' 생성됨")
        
        # 카드 추가하기
        note_id = add_note(
            deck_name=deck_name,
            front="파이썬으로 추가한 카드의 질문",
            back="파이썬으로 추가한 카드의 답변",
            tags=["python", "anki-connect"]
        )
        print(f"새 노트 추가됨, ID: {note_id}")
        
        # 노트 검색하기
        found_notes = find_notes(f"deck:{deck_name}")
        print(f"'{deck_name}' 덱에서 찾은 노트: {found_notes}")
        
        # 첫 번째 노트 정보 가져오기
        if found_notes:
            notes_info = get_notes_info([found_notes[0]])
            print("첫 번째 노트 정보:")
            print(json.dumps(notes_info[0], indent=2, ensure_ascii=False))
            
    except Exception as e:
        print(f"오류 발생: {e}")
        print("Anki가 실행 중인지 확인하세요!")

CSV 파일에서 카드 대량 추가 스크립트

카드를 대량으로 추가할 수 있는 csv_to_anki.py 스크립트도 만들어보겠습니다:

import csv
import json
import urllib.request
import sys

def request_anki(action, **params):
    """Anki-Connect API에 요청을 보내는 기본 함수"""
    request_data = json.dumps({
        'action': action,
        'params': params,
        'version': 6
    }).encode('utf-8')
    
    try:
        response = json.load(urllib.request.urlopen(
            urllib.request.Request('http://localhost:8765', request_data)
        ))
        
        if response['error'] is not None:
            raise Exception(response['error'])
            
        return response['result']
    except Exception as e:
        print(f"오류 발생: {e}")
        return None

def import_from_csv(csv_file, deck_name, model_name="Basic"):
    """
    CSV 파일에서 카드 가져오기
    CSV 파일은 'front', 'back', 'tags' 열이 있어야 함
    """
    added_count = 0
    error_count = 0
    
    with open(csv_file, 'r', encoding='utf-8') as f:
        reader = csv.DictReader(f)
        for row in reader:
            front = row.get('front', '').strip()
            back = row.get('back', '').strip()
            
            if not front or not back:
                print(f"경고: 비어있는 필드 발견 - {row}")
                error_count += 1
                continue
                
            tags = []
            if 'tags' in row and row['tags']:
                tags = [tag.strip() for tag in row['tags'].split(',')]
                
            try:
                # 노트 추가
                note_id = request_anki('addNote', note={
                    'deckName': deck_name,
                    'modelName': model_name,
                    'fields': {
                        'Front': front,  # 한글 Anki: "앞면"
                        'Back': back     # 한글 Anki: "뒷면"
                    },
                    'tags': tags
                })
                
                if note_id:
                    added_count += 1
                    print(f"카드 추가 완료: {front} -> {back}")
                else:
                    print(f"카드 추가 실패: {front} -> {back}")
                    error_count += 1
                    
            except Exception as e:
                print(f"오류 발생: {e}")
                error_count += 1
    
    return added_count, error_count

if __name__ == "__main__":
    if len(sys.argv) < 3:
        print("사용법: python csv_to_anki.py <CSV 파일 경로> <덱 이름>")
        sys.exit(1)
        
    csv_file = sys.argv[1]
    deck_name = sys.argv[2]
    
    # 덱이 존재하지 않으면 생성
    request_anki('createDeck', deck=deck_name)
    
    # CSV에서 카드 가져오기
    added, errors = import_from_csv(csv_file, deck_name)
    
    print(f"\n가져오기 완료!")
    print(f"추가된 카드: {added}")
    print(f"오류 발생: {errors}")

5단계: MCP 연결 및 테스트

설정 확인

모든 것이 올바르게 설정되었는지 확인합니다:

• Anki가 실행 중인지 확인

• Anki-Connect 플러그인이 활성화되어 있는지 확인

• anki-mcp-server가 빌드되었는지 확인

• Claude Desktop 구성 파일이 올바르게 설정되었는지 확인

서버 실행

터미널에서 다음 명령을 실행하여 anki-mcp-server를 시작합니다:

cd /전체/경로/anki-mcp-server
node build/index.js

Claude Desktop에서 연결 테스트

1. Anki를 실행합니다.

2. Claude Desktop을 실행합니다.

3. Claude에게 다음과 같이 요청합니다:

anki://decks

또는

anki://search/deck:current

이 명령은 모든 덱 목록 또는 현재 선택된 덱의 카드를 보여줍니다. 연결이 제대로 되었다면 결과가 표시될 것입니다.

Python 스크립트 테스트

터미널에서 작성한 Python 스크립트를 실행합니다:

python anki_connect_tool.py

스크립트가 성공적으로 실행되면 Anki에 새 덱과 카드가 추가된 것을 확인할 수 있습니다.

6단계: MCP와 Python 통합하기

이제 Claude와 대화할 때 Python 스크립트를 활용하는 방법을 알아보겠습니다.

Claude를 통한 Python 스크립트 실행 요청

Claude에게 다음과 같이 Anki 관련 작업을 요청할 수 있습니다:

Python을 사용하여 "영어 단어장" 덱에 다음 단어들을 추가해주세요:
1. apple - 사과
2. book - 책
3. computer - 컴퓨터

Claude는 이러한 요청을 처리하기 위한 Python 코드를 제공할 것입니다:

import json
import urllib.request

def request_anki(action, **params):
    request_data = json.dumps({
        'action': action,
        'params': params,
        'version': 6
    }).encode('utf-8')
    
    response = json.load(urllib.request.urlopen(
        urllib.request.Request('http://localhost:8765', request_data)
    ))
    
    if response['error'] is not None:
        raise Exception(response['error'])
        
    return response['result']

# 덱 생성 (이미 존재하면 무시됨)
request_anki('createDeck', deck='영어 단어장')

# 단어 추가
words = [
    {"front": "apple", "back": "사과"},
    {"front": "book", "back": "책"},
    {"front": "computer", "back": "컴퓨터"}
]

for word in words:
    note_id = request_anki('addNote', note={
        'deckName': '영어 단어장',
        'modelName': 'Basic',  # 한글 Anki에서는 '기본'
        'fields': {
            'Front': word["front"],  # 한글 Anki에서는 '앞면'
            'Back': word["back"]     # 한글 Anki에서는 '뒷면'
        },
        'tags': ['영어단어']
    })
    print(f"추가됨: {word['front']} - {word['back']}, ID: {note_id}")

print("모든 단어가 성공적으로 추가되었습니다!")

이 코드를 복사하여 터미널에서 실행하면 Anki에 단어가 추가됩니다.

7단계: 문제 해결 및 고급 기능

일반적인 문제 해결

• 연결 문제: Anki가 실행 중인지, Anki-Connect가 활성화되어 있는지 확인합니다.

• CORS 문제: Anki-Connect 구성에서 webCorsOriginList에 "mcp://*"가 추가되어 있는지 확인합니다.

• 필드 이름 문제: Anki 언어 설정에 따라 필드 이름이 다를 수 있습니다. 영문은 "Front"/"Back", 한글은 "앞면"/"뒷면"입니다.

MCP Inspector 사용하기

MCP 서버와의 통신 문제를 디버깅하려면 MCP Inspector를 사용할 수 있습니다:

cd 경로/anki-mcp-server
npm run inspector

이 명령어를 실행하면 브라우저에서 디버깅 도구에 접속할 수 있는 URL이 제공됩니다.

고급 Python 기능 추가하기

학습 진도를 추적하는 기능을 추가해 보겠습니다:

def get_study_stats():
    """학습 통계 가져오기"""
    # 오늘 학습한 카드 수
    reviewed_today = request_anki('getNumCardsReviewedToday')
    
    # 일별 리뷰 통계
    reviews_by_day = request_anki('getNumCardsReviewedByDay')
    
    # 덱별 통계
    decks = request_anki('deckNames')
    deck_stats = {}
    
    for deck in decks:
        stats = request_anki('getDeckStats', decks=[deck])
        deck_stats[deck] = stats[deck]
    
    return {
        'reviewed_today': reviewed_today,
        'reviews_by_day': reviews_by_day,
        'deck_stats': deck_stats
    }

이 함수를 사용하여 학습 통계를 확인할 수 있습니다.

8단계: 자동화 및 정기적인 카드 추가 설정

스케줄링된 작업으로 자동화하기

매일 특정 시간에 새 카드를 자동으로 추가하도록 스크립트를 예약할 수 있습니다:

macOS/Linux (cron 사용)

# crontab 편집
crontab -e

# 매일 오전 9시에 스크립트 실행
0 9 * * * python3 /경로/to/daily_cards.py

Windows (작업 스케줄러 사용)

1. 작업 스케줄러를 열고 '기본 작업 만들기'를 클릭합니다.

2. 이름과 설명을 입력하고 '매일' 트리거를 선택합니다.

3. 시작 시간을 설정하고 동작으로 '프로그램 시작'을 선택합니다.

4. 프로그램/스크립트에 'python'을 입력하고, 인수에 'C:\경로\to\daily_cards.py'를 입력합니다.

자동화를 위한 daily_cards.py 스크립트

import json
import urllib.request
import datetime
import os

def request_anki(action, **params):
    request_data = json.dumps({
        'action': action,
        'params': params,
        'version': 6
    }).encode('utf-8')
    
    try:
        response = json.load(urllib.request.urlopen(
            urllib.request.Request('http://localhost:8765', request_data)
        ))
        
        if response['error'] is not None:
            raise Exception(response['error'])
            
        return response['result']
    except Exception as e:
        print(f"오류 발생: {e}")
        return None

def add_daily_cards():
    """매일 새로운 단어 카드 추가하기"""
    # 오늘 날짜 가져오기
    today = datetime.date.today().strftime("%Y-%m-%d")
    
    # 로그 파일 경로
    log_dir = os.path.dirname(os.path.abspath(__file__))
    log_path = os.path.join(log_dir, "anki_daily_log.txt")
    
    # 로그 기록
    with open(log_path, "a", encoding="utf-8") as log:
        log.write(f"\n===== {today} 실행 =====\n")
        
        try:
            # Anki 실행 확인
            decks = request_anki('deckNames')
            if not decks:
                log.write("Anki가 실행되지 않았거나 연결할 수 없습니다.\n")
                return
                
            deck_name = "일일 단어장"
            
            # 덱이 없으면 생성
            if deck_name not in decks:
                request_anki('createDeck', deck=deck_name)
                log.write(f"새 덱 생성됨: {deck_name}\n")
            
            # 오늘의 단어들 (실제로는 API나 파일에서 가져올 수 있음)
            today_words = [
                {"front": f"단어-{today}-1", "back": f"의미-{today}-1"},
                {"front": f"단어-{today}-2", "back": f"의미-{today}-2"},
                {"front": f"단어-{today}-3", "back": f"의미-{today}-3"}
            ]
            
            # 단어 추가
            for word in today_words:
                note_id = request_anki('addNote', note={
                    'deckName': deck_name,
                    'modelName': 'Basic',  # 필요에 따라 조정
                    'fields': {
                        'Front': word["front"],
                        'Back': word["back"]
                    },
                    'tags': [f'daily-{today}']
                })
                
                if note_id:
                    log.write(f"카드 추가됨: {word['front']} -> {word['back']}\n")
                else:
                    log.write(f"카드 추가 실패: {word['front']}\n")
            
            log.write("일일 카드 추가 완료!\n")
            
        except Exception as e:
            log.write(f"오류 발생: {e}\n")

if __name__ == "__main__":
    add_daily_cards()

9단계: 간편한 Python 유틸리티 만들기

매번, 이 코드를 한 줄, 한 줄, 작성하기보다는 더 편리하게 사용할 수 있도록 포괄적인 유틸리티를 만들어 보겠습니다.

다음과 같은 종합 Python 유틸리티 파일을 만들어 놓고 필요할 때마다 사용하면 편리합니다:

anki_helper.py 만들기

# anki_helper.py - 안키 관리 도우미
import json
import urllib.request
import sys
import csv

def request_anki(action, **params):
    """Anki-Connect API에 요청을 보내는 기본 함수"""
    request_data = json.dumps({
        'action': action,
        'params': params,
        'version': 6
    }).encode('utf-8')
    
    try:
        response = json.load(urllib.request.urlopen(
            urllib.request.Request('http://localhost:8765', request_data)
        ))
        
        if response['error'] is not None:
            raise Exception(response['error'])
            
        return response['result']
    except Exception as e:
        print(f"오류 발생: {e}")
        return None

def show_decks():
    """모든 덱 목록 표시"""
    decks = request_anki('deckNames')
    if decks:
        print("현재 안키 덱 목록:")
        for i, deck in enumerate(decks, 1):
            print(f"{i}. {deck}")
        print(f"\n총 {len(decks)}개의 덱이 있습니다.")
    return decks

def add_card(deck_name, front, back, tags=None):
    """카드 추가"""
    if tags is None:
        tags = []
        
    note_id = request_anki('addNote', note={
        'deckName': deck_name,
        'modelName': 'Basic',  # 한글 Anki: '기본'
        'fields': {
            'Front': front,  # 한글 Anki: '앞면'
            'Back': back     # 한글 Anki: '뒷면'
        },
        'tags': tags
    })
    
    if note_id:
        print(f"카드가 성공적으로 추가되었습니다. (ID: {note_id})")
    return note_id

def add_cards_from_csv(file_path, deck_name):
    """CSV 파일에서 여러 카드 추가"""
    created = 0
    errors = 0
    
    with open(file_path, 'r', encoding='utf-8') as f:
        reader = csv.reader(f)
        for row in reader:
            if len(row) >= 2:
                front = row[0].strip()
                back = row[1].strip()
                tags = []
                if len(row) > 2:
                    tags = [tag.strip() for tag in row[2].split(',')]
                
                if add_card(deck_name, front, back, tags):
                    created += 1
                else:
                    errors += 1
    
    print(f"\n{created}개의 카드가 추가되었습니다. 오류: {errors}개")

def create_deck(deck_name):
    """새 덱 생성"""
    deck_id = request_anki('createDeck', deck=deck_name)
    if deck_id:
        print(f"덱 '{deck_name}'이(가) 생성되었습니다.")
    return deck_id

def search_cards(query):
    """카드 검색"""
    card_ids = request_anki('findCards', query=query)
    if card_ids:
        print(f"{len(card_ids)}개의 카드를 찾았습니다.")
        card_info = request_anki('cardsInfo', cards=card_ids[:10])  # 처음 10개만 보여줌
        
        print("\n--- 검색 결과 (최대 10개) ---")
        for i, card in enumerate(card_info, 1):
            print(f"{i}. 앞면: {card['fields']['Front']['value']}")
            print(f"   뒷면: {card['fields']['Back']['value']}")
            print(f"   덱: {card['deckName']}")
            print(f"   태그: {card['tags']}")
            print()
    else:
        print("일치하는 카드가 없습니다.")
    return card_ids

def update_card(card_id, front=None, back=None, tags=None):
    """카드 내용 업데이트"""
    note_info = request_anki('notesInfo', notes=[card_id])
    if not note_info:
        return False
        
    note = note_info[0]
    fields = note['fields']
    
    if front:
        fields['Front']['value'] = front
    if back:
        fields['Back']['value'] = back
        
    result = request_anki('updateNoteFields', note={
        'id': card_id,
        'fields': {
            'Front': fields['Front']['value'],
            'Back': fields['Back']['value']
        }
    })
    
    if tags:
        request_anki('clearNoteTags', notes=[card_id])
        request_anki('addTags', notes=[card_id], tags=" ".join(tags))
        
    if result:
        print("카드가 성공적으로 수정되었습니다.")
    return result

def show_stats():
    """학습 통계 표시"""
    reviewed_today = request_anki('getNumCardsReviewedToday')
    reviews_by_day = request_anki('getNumCardsReviewedByDay')
    
    print(f"오늘 학습한 카드: {reviewed_today}장")
    print("\n최근 일주일 학습 통계:")
    for day, count in reviews_by_day.items():
        print(f"- {day}: {count}장")

def show_help():
    """도움말 표시"""
    print("\n=== 안키 도우미 사용법 ===")
    print("python anki_helper.py decks - 모든 덱 보기")
    print("python anki_helper.py create '덱이름' - 새 덱 생성")
    print("python anki_helper.py add '덱이름' '앞면' '뒷면' '태그1,태그2' - 카드 추가")
    print("python anki_helper.py import '파일경로.csv' '덱이름' - CSV 파일에서 카드 가져오기")
    print("python anki_helper.py search '검색어' - 카드 검색")
    print("python anki_helper.py stats - 학습 통계 보기")
    print("python anki_helper.py update '카드ID' '새앞면' '새뒷면' '태그1,태그2' - 카드 수정")
    print("python anki_helper.py help - 도움말 보기")

# 명령행 인터페이스
if __name__ == "__main__":
    if len(sys.argv) < 2:
        show_help()
        sys.exit(1)
        
    command = sys.argv[1].lower()
    
    if command == "decks":
        show_decks()
        
    elif command == "create" and len(sys.argv) > 2:
        create_deck(sys.argv[2])
        
    elif command == "add" and len(sys.argv) >= 4:
        deck_name = sys.argv[2]
        front = sys.argv[3]
        back = sys.argv[4] if len(sys.argv) > 4 else ""
        tags = sys.argv[5].split(',') if len(sys.argv) > 5 else []
        add_card(deck_name, front, back, tags)
        
    elif command == "import" and len(sys.argv) > 3:
        add_cards_from_csv(sys.argv[2], sys.argv[3])
        
    elif command == "search" and len(sys.argv) > 2:
        search_cards(sys.argv[2])
        
    elif command == "stats":
        show_stats()
        
    elif command == "update" and len(sys.argv) > 2:
        card_id = int(sys.argv[2])
        front = sys.argv[3] if len(sys.argv) > 3 else None
        back = sys.argv[4] if len(sys.argv) > 4 else None
        tags = sys.argv[5].split(',') if len(sys.argv) > 5 else None
        update_card(card_id, front, back, tags)
        
    elif command == "help":
        show_help()
        
    else:
        print("잘못된 명령입니다.")
        show_help()

쉬운 사용 방법

이 스크립트를 사용하는 방법은 다음과 같습니다:

1. 덱 목록 보기:

   python anki_helper.py decks
   

2. 새 덱 만들기:

   python anki_helper.py create "영어 단어장"
   

3. 카드 추가하기:

   python anki_helper.py add "영어 단어장" "apple" "사과" "영어,과일"
   

4. CSV 파일에서 카드 일괄 추가하기:

   python anki_helper.py import "단어목록.csv" "영어 단어장"
   

   (CSV 파일은 각 줄에 "앞면,뒷면,태그1,태그2" 형식으로 저장)

5. 카드 검색하기:

   python anki_helper.py search "tag:영어"
   

6. 학습 통계 보기:

   python anki_helper.py stats
   

7. 카드 내용 수정하기:

   python anki_helper.py update 1234567890 "새 질문" "새 답변" "새태그1,새태그2"
   

10단계: 바로가기 스크립트 만들기

더 편리하게 사용하기 위해 바로가기 스크립트를 만들 수 있습니다.

macOS/Linux 사용자를 위한 쉘 스크립트

#!/bin/bash
# anki.sh

# 안키가 실행 중인지 확인
ps aux | grep -v grep | grep -q "Anki"
if [ $? -ne 0 ]; then
    echo "안키가 실행 중이지 않습니다. 안키를 먼저 실행해주세요."
    open -a Anki
    sleep 3  # 안키가 시작될 때까지 대기
fi

# 안키 도우미 실행
python /절대/경로/anki_helper.py "$@"

이 스크립트를 anki.sh로 저장하고 실행 권한을 부여한 후:

chmod +x anki.sh

이제 다음과 같이 간단히 사용할 수 있습니다:

./anki.sh decks
./anki.sh add "영어 단어장" "book" "책"

Windows 사용자를 위한 배치 파일

@echo off
REM anki.bat

REM 안키가 실행 중인지 확인
tasklist /FI "IMAGENAME eq anki.exe" | find "anki.exe" > nul
if errorlevel 1 (
    echo 안키가 실행 중이지 않습니다. 안키를 먼저 실행해주세요.
    start "" "C:\Program Files\Anki\anki.exe"
    timeout /t 3 > nul
)

REM 안키 도우미 실행
python C:\절대\경로\anki_helper.py %*

이 스크립트를 anki.bat로 저장한 후 다음과 같이 사용할 수 있습니다:

anki.bat decks
anki.bat add "영어 단어장" "book" "책"

MCP vs Python 스크립트 방식 비교

MCP 방식의 장점

• Claude와 직접 통합되어 자연스러운 대화 경험 제공

• 별도의 코드 작성이나 실행 없이 명령 수행 가능

• Claude의 추론 능력을 활용한 고급 기능 가능

Python 스크립트 방식의 장점

• 더 안정적이고 검증된 방식

• 커스터마이징과 확장이 쉬움

• MCP 설정 문제에 영향을 받지 않음

• 자동화와 스케줄링이 용이함

결론

이 튜토리얼에서는 Python을 사용하여 Anki와 Claude를 연결하는 두 가지 방법(MCP 직접 연결과 Python 스크립트)을 살펴봤습니다. 이 통합을 통해 AI의 도움을 받아 효율적으로 학습 자료를 관리하고, 자동화된 카드 생성 및 관리가 가능해졌습니다.

MCP 방식은 자연스러운 대화 경험을 제공하지만 설정이 복잡하고 문제가 발생할 수 있습니다. Python 스크립트 방식은 더 안정적이고 커스터마이징이 쉽지만 매번 코드를 실행해야 하는 번거로움이 있습니다.

두 방식을 상황에 맞게 활용하면, 학습 과정을 크게 개선하고 AI의 지능을 활용하여 더 효과적인 학습 경험을 만들 수 있을 것입니다.

추가 자료

• Anki 공식 문서

• Anki-Connect GitHub

• anki-mcp-server GitHub

태그: #Anki #Python #AI #Claude #학습자동화 #플래시카드 #MCP