academic-research-skills: AI 기반 학술 연구 파이프라인 31K 스타 오픈소스 스킬 (31K Stars)

# CLI로 한 줄 설치
/플러그인 마켓플레이스에 Imbad0202/학술 연구 기술 추가
/plugin, 학술-연구-skills 설치

git 클론 https://github.com/Imbad0202/academic-research-skills.git
# .클로드/스킬/또는 제트브레인 스킬 디렉토리에 심링크

git 클론 https://github.com/Imbad0202/academic-research-skills.git
ln -s ~/학술 연구 - skills ~/.claude / skills

# citation_verifier.py 
JSON 가져오기 
pathlib import 경로에서 
import 선택 사항 입력에서 

클래스 CitationVerifier: 
""" 
이에 대한 주장의 정당성을 입증하는 클래스. 
DOI, arXiv ID, Crossref API를 활용하여 정보를 검증합니다. 
""" 

def __init__(self, crossref_api_url="https://api.crossref.org/works"): 
self.crossref_url = crossref_api_url 
self.arxiv_url = "http://export.arxiv.org/api/query" 

def verify_by_doi(self, doi: str) -> 선택사항[dict]: 
"""DOI로 정보 검증""" 
수입요청 

url = f"{self.crossref_url}/{doi}" 
응답 = 요청.get(url, headers={"Accept": "application/json"}) 

response.status_code == 200인 경우: 
데이터 = response.json()["메시지"] 
반환 { 
"확인됨": 사실, 
"제목": data.get("제목", ["알 수 없음"])[0], 
"저자": [a.get("가족", "") for a in data.get("저자", [])], 
"연도": data.get("published-print", {}).get("date-parts", [[0]])[0][0], 
"장소": data.get("컨테이너 제목", ["알 수 없음"])[0], 
"도이": 도이 
} 
return {"검증됨": 거짓, "오류": f"DOI 검증 실패: {doi}"} 

def verify_by_arxiv(self, arxiv_id: str) -> 선택사항[dict]: 
"""arXiv ID로 정보 검증""" 
수입요청 
xml.etree에서 ElementTree를 ET로 가져옵니다. 

쿼리 = f"id:{arxiv_id}" 
url = f"{self.arxiv_url}?search_query={query}&max_results=1" 
응답 = 요청.get(url) 

response.status_code == 200인 경우: 
루트 = ET.fromstring(response.content) 
네임스페이스 = {"atom": "http://www.w3.org/2005/Atom"} 

항목 = root.find("atom:entry", 네임스페이스) 
항목이 None이 아닌 경우: 
반환 { 
"확인됨": 사실, 
"제목": Entry.find("atom:title", 네임스페이스).text.strip(), 
"저자": [ 
a.find("atom:name", 네임스페이스).text 
항목에 대한 경우.findall("atom:author", 네임스페이스) 
], 
"연도": Entry.find("atom:published", 네임스페이스).text[:4], 
"arxiv_id": arxiv_id, 
"추상": Entry.find("atom:summary", 네임스페이스).text[:200] 
} 
반환 {"검증됨": False, "오류": f"arXiv 확인 실패: {arxiv_id}"} 

def triangulate(self, citations: list[dict]) -> dict: 
"""삼각측량법: 여러 내용으로 검증했습니다""" 
결과 = [] 
인용문의 경우: 
cit에 "doi"가 있는 경우: 
결과 = self.verify_by_doi(cit["doi"]) 
cit의 elif "arxiv_id": 
결과 = self.verify_by_arxiv(cit["arxiv_id"]) 
그 외: 
결과 = {"검증됨": 거짓, "오류": "DOI 또는 arXiv ID 없음"} 

results.append({**cit, **결과}) 

# 검증을 통해 
Verified_count = sum(r.get("verified"))인 경우 결과의 r에 대해 1 
총계 = len(결과) 

반환 { 
"인용": 결과, 
"verification_rate": verify_count / 총계(총계 > 0인 경우 그렇지 않으면 0), 
"failed_citations": [r.get("verified")가 아닌 경우 결과에 r에 대한 r] 
}

# partitioned_writer.py 
PartitionedPaperWriter 클래스: 
""" 
긴 소속을 유지하며 생성하여 일관성을 유지합니다. 
각 인스턴스는 생성된 후, 인터페이스로 연결되었습니다. 
""" 

def __init__(self, llm_client): 
self.llm = llm_client 
self.partitions = [] 
self.context_summary = "" 

def generate_partition(self, partition_type: str, 내용: str, 
이전_요약: str = "") -> str: 
"""단일 복제""" 
프롬프트 = f""" 
[파티션 유형]: {파티션_유형} 
[이전 컨텍스트]: {previous_summary} 
[지침]: {partition_type} 섹션을 생성하세요. 
이전 컨텍스트와의 일관성을 유지합니다. 
모든 주장이 적절하게 인용되었는지 확인하세요. 

[콘텐츠]: {콘텐츠} 
""" 
응답 = self.llm.generate(프롬프트, max_tokens=4000) 

#누구든지 데이터 저장 
self.partitions.append({ 
"유형": 파티션_유형, 
"콘텐츠": 응답, 
"token_count": len(response.split()), 
"has_citations": self.count_citations(응답) 
}) 

응답 반환 

def generate_full_paper(self, 주제: str, 섹션: 목록[str]) -> dict: 
"""조직 게시 생성(섹션별 개체)""" 
종이 = {} 
요약 = "" 

섹션의 섹션: 
print(f"📝 생성 중: {섹션}") 
partition_content = self.generate_partition( 
partition_type=섹션, 
내용=주제, 
이전_요약=요약 
) 
종이[섹션] = partition_content 

# 다음 멤버를 구성하여 작성 
요약 += f"[{섹션}]: {partition_content[:500]}... " 

반환 종이 

def count_citations(self, text: str) -> int: 
""" 텍스트 내 내용을 처리할 수 있습니다""" 
다시 가져오기 
len(re.findall(r'\[.*?\]', text))를 반환합니다. 

def get_statistics(self) -> 사전: 
"""파티션 통계""" 
반환 { 
"total_partitions": len(self.partitions), 
"total_tokens": sum(p["token_count"] for p in self.partitions), 
"partitions_with_citations": 합계( 
p["has_citations"] > 0인 경우 self.partitions의 p에 대해 1 
) 
}

# 토큰_옵티마이저.py 
클래스 TokenCostOptimizer: 
"""ARS의 해석을 최적화하는 클래스""" 

# Claude Sonnet 가격 (2026년 기준) 
INPUT_PRICE_PER_1M = 3.00 # $3.00 / 1M 토큰 
OUTPUT_PRICE_PER_1M = 15.00 # $15.00 / 100만 토큰 

def __init__(self, max_budget=10.00): 
self.max_budget = 최대_예산 
self.total_input_tokens = 0 
self.total_output_tokens = 0 

def estimate_cost(self, input_tokens: int, output_tokens: int) -> float: 
"""예상비용 계산""" 
input_cost = (input_tokens / 1_000_000) * self.INPUT_PRICE_PER_1M 
output_cost = (output_tokens / 1_000_000) * self.INPUT_PRICE_PER_1M 
input_cost + output_cost를 반환합니다. 

def Chunk_text_for_efficiency(self, text: str, max_tokens_per_chunk=3000) -> 목록[str]: 
""" 텍스트를 효율적으로 나누어 """ 
단어 = text.split() 
덩어리 = [] 
현재_청크 = [] 
current_tokens = 0 

단어로 말하면: 
current_chunk.append(워드) 
current_tokens += 1 

current_tokens >= max_tokens_per_chunk인 경우: 
Chunks.append(" ".join(current_chunk)) 
현재_청크 = [] 
current_tokens = 0 

현재_청크인 경우: 
Chunks.append(" ".join(current_chunk)) 

청크 반환 

def 계산_roi(self, manual_hours: 부동, 도구_시간_시간: 부동, 
hourly_rate=50.0) -> 사전: 
"""ROI를 계산""" 
manual_cost = manual_hours * 시간당 요금 
tool_cost = self.estimate_cost(0, 0) # 실제로 의미있는 비용 

hour_saved = manual_hours - tool_time_hours 
절약 = 시간_절감 * 시간당_비율 

반환 { 
"수동_비용": 수동_비용, 
"tool_cost": 도구_비용, 
"net_savings": 절감액 - tool_cost, 
"time_saved_hours": 시간_저장, 
"roi_percentage": ((절감 - tool_cost) / tool_cost * 100) if tool_cost > 0 else float('inf') 
}

# 실험_에이전트.py 
무작위로 가져오기 
데이터 클래스에서 데이터 클래스 가져오기, 필드 
import List, Dict 입력에서 

@데이터클래스 
클래스 실험결과: 
"""실험 결과 데이터 클래스""" 
이름: str 
가설: str 
데이터세트: str 
모델: str 
측정항목: Dict[str, float] = field(default_factory=dict) 
참고: str = "" 

클래스 ExperimentAgent: 
""" 
실험 설계를 지원하고 결과를 추적하는 에이전트. 
ARS와 실험을 통해 연구 결과와 실험 데이터를 연결합니다. 
""" 

def __init__(self): 
self.experiments: List[ExperimentResult] = [] 
self.results_db: Dict[str, List[ExperimentResult]] = {} 

def design_experiment(self, 가설: str, 데이터 세트_이름: str, 
기준선_모델: str) -> 실험결과: 
"""새로운 실험 설계""" 
실험 = 실험결과( 
이름=f"exp_{len(self.experiments)+1}", 
가설=가설, 
데이터세트=데이터세트_이름, 
모델=기준_모델 
) 
self.experiments.append(실험) 

반환 실험 

def add_result(self, Experiment_name: str, 측정항목: Dict[str, float], 
참고: str = ""): 
"""실험 결과 추가""" 
self.experiments의 exp의 경우: 
exp.name == 실험_이름인 경우: 
exp.metrics = 지표 
exp.notes = 메모 
exp.dataset가 self.results_db에 없는 경우: 
self.results_db[exp.dataset] = [] 
self.results_db[exp.dataset].append(exp) 
반환 

raise ValueError(f"{experiment_name} 실험을 찾을 수 없습니다.") 

def Compare_experiments(self, 데이터 세트: str) -> dict: 
"""같은 데이터셋에 대한 실험 비교""" 
데이터세트가 self.results_db에 없는 경우: 
return {"error": "이 데이터 세트에 대한 실험이 없습니다"} 

실험 = self.results_db[데이터세트] 
비교 = {} 

실험 경험의 경우: 
비교[exp.이름] = { 
"가설": exp.가설, 
"모델": exp.모델, 
"metrics": exp.metrics, 
"노트": exp.notes 
} 

# 가장 좋은 모델 찾기 
best_model = 없음 
최고 점수 = 0 

실험 경험의 경우: 
메트릭의 경우 exp.metrics.items()의 점수: 
metric.startswith("accuracy") 또는 metric.startswith("f1")인 경우: 
점수 > 최고 점수인 경우: 
best_score = 점수 
best_model = exp.name 

반환 { 
"실험": 비교, 
"최고_모델": 최고_모델, 
"최고_점수": 최고_점수, 
"total_experiments": len(실험) 
} 

def generate_experiment_report(self) -> str: 
"""실험에 포함하여 작성(논문 초안에)""" 
보고서 = "실험 결과 #개\n\n" 

데이터 세트의 경우 self.results_db.items()에서 실험합니다. 
보고서 += f"## 데이터 세트: {dataset}\n\n" 
보고서 += "| 실험 | 모델 | 측정항목 | 참고 |\n" 
보고 += "|------------|-------|---------|-------|\n" 

실험 경험의 경우: 
metrics_str = ", ".join( 
exp.metrics.items()의 k, v에 대한 f"{k}: {v:.4f}" 
) 
보고서 += f"| {exp.name} | {exp.model} | {metrics_str} | {exp.notes} |\n" 

보고 += "\n" 

보고서 반환

# 템플릿/nature_style.yaml
저널: "네이처"
형식:
  폰트: "타임즈 뉴 로만"
  폰트_사이즈: 12
  line_spacing: 2.0
  여백: "전면 1인치"
구조:
  max_word_count: 3000
  섹션:
    - 제목: "추상"
      최대 길이: 250
      필수: true
    - 제목: "소개"
      필수: true
    - 제목: "결과"
      필수: true
    - 제목: "토론"
      필수: true
    - 제목: "방법"
      필수: true
  참조:
    스타일: "하버드"
    최대_카운트: 50
인용 형식: "작성자 (연도)"
수치:
  해상도: 300
  형식: "TIFF"
  캡션_위치: "below"

# 템플릿/icml_style.yaml
저널: "ICML"
형식:
  폰트: "타임즈 뉴 로만"
  폰트_사이즈: 10
  line_spacing: 더블
  여백: "전면 1인치"
구조:
  max_word_count: 6000
  페이지_limit: 9
  섹션:
    - 제목: "추상"
      최대 길이: 200
      필수: true
    - 제목: "소개"
      필수: true
    - 제목: "관련 작업"
      필수: true
    - 제목: "방법"
      필수: true
    - 제목: "실험"
      필수: true
    - 제목: "결론"
      필수: true
  참조:
    스타일: "ACL"
    max_count: 100
인용_형식: "[N]"
수치:
  해상도: 300
  형식: "PDF"
  캡션_위치: "below"

# version_tracker.py 
날짜/시간에서 날짜/시간 가져오기 
JSON 가져오기 
pathlib import 경로에서 

클래스 ResearchVersionTracker: 
"""연구 버전 관리 시스템""" 

def __init__(self, project_dir="./research_project"): 
self.project_dir = 경로(project_dir) 
self.versions_dir = self.project_dir / "버전" 
self.versions_dir.mkdir(부모=True,exist_ok=True) 

def create_version(self, paper_content: str, version_name: str = 없음, 
변경사항: str = "") -> str: 
"""새 버전 생성""" 
version_name이 없음인 경우: 
타임스탬프 = datetime.now().strftime("%Y%m%d_%H%M%S") 
버전_이름 = f"v{타임스탬프}" 

버전_데이터={ 
"버전": 버전_이름, 
"타임스탬프": datetime.now().isoformat(), 
"word_count": len(paper_content.split()), 
"section_count": paper_content.count("## "), 
"citation_count": paper_content.count("["), 
"변경 사항": 변경 사항 
} 

# 버전 파일 생성 
version_file = self.versions_dir / f"{version_name}.json" 
version_file.write_text(json.dumps(version_data, indent=2, verify_ascii=False)) 

# 논문 내용 작성 
paper_file = self.versions_dir / f"{버전_이름}_paper.md" 
paper_file.write_text(paper_content) 

# 업데이트 업데이트 
self._update_index(버전_이름, 버전_데이터) 

버전_이름 반환 

def list_versions(self) -> 목록[dict]: 
"""저장된 버전 목록""" 
버전 = [] 
self.versions_dir.glob("*.json")의 json_file에 대해: 
json_file.name.endswith("_paper.json")인 경우: 
계속하다 
versions.append(json.loads(json_file.read_text())) 

return sorted(versions, key=lambda v: v["timestamp"], reverse=True) 

def get_version(self, 버전_이름: str) -> dict: 
"""특정 버전 조회""" 
json_file = self.versions_dir / f"{version_name}.json" 
json_file.exists()인 경우: 
json.loads(json_file.read_text())를 반환합니다. 
{} 반환 

def _update_index(self, 버전_이름: str, 데이터: dict): 
"""버전 업데이트""" 
index_file = self.versions_dir / "index.json" 
index = json.loads(index_file.read_text()) if index_file.exists() else [] 
index.append(데이터) 
index_file.write_text(json.dumps(index, indent=2, verify_ascii=False))

# .github/workflows/research-pipeline.yml 
이름: 학술 연구 파이프라인 

에: 
일정: 
- cron: '0 6 * * 1' # 모두 함께 냄비 6시 
작업 흐름_디스패치: 
입력: 
주제: 
설명: '연구 주제' 
필수: 사실 
기본값: '다중 에이전트 강화 학습' 

직업: 
연구: 
실행: 우분투 최신 
단계: 
- 용도: actions/checkout@v4 

- 이름: Python 설치 
용도: actions/setup-python@v5 
와: 
파이썬 버전: '3.12' 

- 이름 : ARS 설치 
실행: pip install Academic-Research-Skills 

- 이름 : 딥리서치 
실행: | 
/deep-research "${{ github.event.inputs.topic || '다중 에이전트 강화 학습' }}" 

- 이름 : 초안 용지 
실행: | 
/academic-paper "${{ github.event.inputs.topic || '다중 에이전트 강화 학습' }}" 

- 이름 : 자동 리뷰 
실행: | 
/academic-review ./output/draft.md 

- 이름: 인용 보고서 생성 
실행: Python scripts/verify_citations.py 

- 이름 : 업로드 결과 
용도: actions/upload-artifact@v4 
와: 
이름: 연구 결과 
경로: | 
출력/draft.md 
출력/review.md 
출력/citations.json