提交 b7e2693e authored 作者: zhangqianwei's avatar zhangqianwei

ljy_收集 5~10 个 GitHub 热门仓库 README + 目录结构

上级 395b530b
import sys
from pathlib import Path
from typing import Any
try:
from github_client import GitHubClient
from schemas import RawRepoRecord, RepoCandidate
except ImportError:
CURRENT_DIR = Path(__file__).resolve().parent
if str(CURRENT_DIR) not in sys.path:
sys.path.insert(0, str(CURRENT_DIR))
from github_client import GitHubClient
from schemas import RawRepoRecord, RepoCandidate
def build_api_source(owner: str, repo: str, default_branch: str) -> dict[str, str]:
return {
"repo_api": f"https://api.github.com/repos/{owner}/{repo}",
"readme_api": f"https://api.github.com/repos/{owner}/{repo}/readme",
"tree_api": (
f"https://api.github.com/repos/{owner}/{repo}/git/trees/"
f"{default_branch}?recursive=1"
),
}
def _extract_tree_items(tree_payload: dict[str, Any]) -> list[dict[str, Any]]:
items = tree_payload.get("tree", [])
if not isinstance(items, list):
return []
return [item for item in items if isinstance(item, dict)]
def collect_single_repo(candidate: RepoCandidate, client: GitHubClient | None = None) -> RawRepoRecord:
github_client = client or GitHubClient()
owner = candidate["owner"]
repo = candidate["repo"]
repo_meta = github_client.get_repo_meta(owner, repo)
default_branch = str(repo_meta.get("default_branch") or "main")
readme_payload = github_client.get_readme(owner, repo)
tree_payload = github_client.get_repo_tree(owner, repo, default_branch)
return RawRepoRecord(
repo_name=str(repo_meta.get("name") or repo),
owner=owner,
repo_url=str(repo_meta.get("html_url") or candidate["repo_url"]),
description=str(repo_meta.get("description") or ""),
stars=int(repo_meta.get("stargazers_count") or 0),
forks=int(repo_meta.get("forks_count") or 0),
watchers=int(repo_meta.get("watchers_count") or 0),
primary_language=str(repo_meta.get("language") or ""),
topics=list(repo_meta.get("topics") or []),
default_branch=default_branch,
updated_at=str(repo_meta.get("updated_at") or ""),
readme_text=str(readme_payload.get("content") or ""),
tree_items=_extract_tree_items(tree_payload),
api_source=build_api_source(owner, repo, default_branch),
)
from pathlib import Path
BASE_DIR = Path(__file__).resolve().parents[2]
DATA_DIR = BASE_DIR / "shared" / "data" / "github_repos"
GITHUB_API_BASE = "https://api.github.com"
REQUEST_TIMEOUT = 20
RAW_OUTPUT_DIR = DATA_DIR / "raw"
NORMALIZED_OUTPUT_DIR = DATA_DIR / "normalized"
LOG_OUTPUT_DIR = DATA_DIR / "logs"
CANDIDATES_FILE = DATA_DIR / "candidates.json"
import json
import os
import sys
from dataclasses import dataclass
from pathlib import Path
from typing import Any
from urllib.error import HTTPError, URLError
from urllib.parse import quote, urlencode
from urllib.request import Request, urlopen
try:
from config import GITHUB_API_BASE, REQUEST_TIMEOUT
except ImportError:
CURRENT_DIR = Path(__file__).resolve().parent
if str(CURRENT_DIR) not in sys.path:
sys.path.insert(0, str(CURRENT_DIR))
from config import GITHUB_API_BASE, REQUEST_TIMEOUT
class GitHubApiError(RuntimeError):
"""Raised when GitHub API requests fail."""
@dataclass(slots=True)
class GitHubClient:
token: str | None = None
api_base: str = GITHUB_API_BASE
timeout: int = REQUEST_TIMEOUT
def __post_init__(self) -> None:
if self.token is None:
self.token = os.getenv("GITHUB_TOKEN") or os.getenv("GITHUB_API_TOKEN")
def _build_headers(self) -> dict[str, str]:
headers = {
"Accept": "application/vnd.github+json",
"User-Agent": "studyweb-repo-ingestion",
"X-GitHub-Api-Version": "2022-11-28",
}
if self.token:
headers["Authorization"] = f"Bearer {self.token}"
return headers
def _request_json(self, url: str) -> dict[str, Any]:
request = Request(url=url, headers=self._build_headers(), method="GET")
try:
with urlopen(request, timeout=self.timeout) as response:
payload = response.read().decode("utf-8")
except HTTPError as exc:
message = exc.read().decode("utf-8", errors="replace")
raise GitHubApiError(
f"GitHub API request failed with status {exc.code}: {message}"
) from exc
except URLError as exc:
raise GitHubApiError(f"GitHub API connection failed: {exc.reason}") from exc
try:
return json.loads(payload)
except json.JSONDecodeError as exc:
raise GitHubApiError("GitHub API returned invalid JSON.") from exc
def get_repo_meta(self, owner: str, repo: str) -> dict[str, Any]:
owner_name = quote(owner)
repo_name = quote(repo)
url = f"{self.api_base}/repos/{owner_name}/{repo_name}"
return self._request_json(url)
def get_readme(self, owner: str, repo: str) -> dict[str, Any]:
owner_name = quote(owner)
repo_name = quote(repo)
url = f"{self.api_base}/repos/{owner_name}/{repo_name}/readme"
return self._request_json(url)
def get_repo_tree(self, owner: str, repo: str, ref: str) -> dict[str, Any]:
owner_name = quote(owner)
repo_name = quote(repo)
encoded_ref = quote(ref)
url = (
f"{self.api_base}/repos/{owner_name}/{repo_name}/git/trees/"
f"{encoded_ref}?recursive=1"
)
return self._request_json(url)
def search_repositories(
self,
query: str,
sort: str = "stars",
order: str = "desc",
per_page: int = 10,
page: int = 1,
) -> dict[str, Any]:
params = urlencode(
{
"q": query,
"sort": sort,
"order": order,
"per_page": per_page,
"page": page,
}
)
url = f"{self.api_base}/search/repositories?{params}"
return self._request_json(url)
import json
import re
import sys
from pathlib import Path
from typing import Any
try:
from knowledge_schema import build_knowledge_json_schema, validate_knowledge_record
from prompt_builder import build_prompt_packet
except ImportError:
CURRENT_DIR = Path(__file__).resolve().parent
if str(CURRENT_DIR) not in sys.path:
sys.path.insert(0, str(CURRENT_DIR))
from knowledge_schema import build_knowledge_json_schema, validate_knowledge_record
from prompt_builder import build_prompt_packet
BASE_DIR = Path(__file__).resolve().parents[2]
DATA_DIR = BASE_DIR / "shared" / "data" / "github_repos"
RAW_DIR = DATA_DIR / "raw"
NORMALIZED_DIR = DATA_DIR / "normalized"
KNOWLEDGE_PROMPTS_DIR = DATA_DIR / "knowledge_prompt_packets"
KNOWLEDGE_OUTPUTS_DIR = DATA_DIR / "knowledge_outputs"
KNOWLEDGE_SCHEMA_DIR = DATA_DIR / "knowledge_schema"
MAX_KNOWLEDGE_POINTS = 8
DIRECTORY_CATEGORY_MAP = {
"api": "接口设计",
"app": "应用入口",
"build": "构建系统",
"core": "核心架构",
"docs": "文档体系",
"docs_src": "文档源码",
"examples": "示例用法",
"extensions": "扩展机制",
"fastapi": "框架源码",
"frontend": "前端实现",
"lib": "核心库",
"models": "模型实现",
"notebooks": "实验样例",
"python": "Python 实现",
"remote": "远程能力",
"scripts": "工程脚本",
"server": "服务部署",
"sklearn": "机器学习实现",
"src": "核心源码",
"tests": "测试体系",
"proto": "协议定义",
}
TOPIC_CATEGORY_MAP = {
"agent": "Agent 机制",
"agents": "Agent 机制",
"ai-agents": "Agent 机制",
"api": "接口设计",
"async": "异步编程",
"asyncio": "异步编程",
"audio": "多模态模型",
"computer-vision": "多模态模型",
"dag": "工作流编排",
"deep-learning": "深度学习",
"embedding": "向量表示",
"fastapi": "Web 框架设计",
"framework": "框架设计",
"generative-ai": "大模型应用",
"json-schema": "数据校验",
"langgraph": "Agent 编排",
"llm": "大模型应用",
"machine-learning": "机器学习",
"multiagent": "Agent 机制",
"natural-language-processing": "自然语言处理",
"nlp": "自然语言处理",
"openapi": "接口文档",
"orchestration": "工作流编排",
"pretrained-models": "预训练模型",
"prompt": "Prompt 设计",
"pydantic": "数据模型",
"rag": "检索增强生成",
"scheduler": "任务调度",
"streamlit": "数据应用框架",
"tensor": "张量计算",
"transformer": "Transformer 模型",
"vlm": "多模态模型",
"web": "Web 服务",
}
TOPIC_DISPLAY_MAP = {
"agents": "Agent 机制",
"ai-agents": "AI Agent 应用",
"api": "API 设计",
"audio": "音频模型能力",
"async": "异步编程",
"asyncio": "asyncio 并发模型",
"computer-vision": "计算机视觉",
"data-analysis": "数据分析",
"data-science": "数据科学",
"data-visualization": "数据可视化",
"deepseek": "DeepSeek 模型生态",
"deep-learning": "深度学习",
"editor": "编辑器架构",
"electron": "Electron 桌面壳",
"fastapi": "FastAPI 框架设计",
"generative-ai": "生成式 AI 应用",
"json-schema": "JSON Schema 校验",
"langgraph": "LangGraph 编排",
"llm": "大模型应用",
"machine-learning": "机器学习",
"model-hub": "模型仓库生态",
"multiagent": "多 Agent 协作",
"natural-language-processing": "自然语言处理",
"nlp": "自然语言处理",
"openapi": "OpenAPI 文档规范",
"pretrained-models": "预训练模型",
"pydantic": "Pydantic 数据模型",
"pytorch": "PyTorch 生态",
"pytorch-transformers": "PyTorch Transformer 实现",
"rag": "RAG 检索增强",
"speech-recognition": "语音识别",
"statistics": "统计建模",
"streamlit": "Streamlit 数据应用框架",
"transformer": "Transformer 模型",
"visual-studio-code": "VS Code 生态",
"vlm": "视觉语言模型",
}
FEATURE_NAME_MAP = {
"easy": "低学习成本",
"fast": "高性能",
"fast to code": "开发效率",
"fewer bugs": "降低错误率",
"intuitive": "编辑器友好",
"live editing": "实时编辑反馈",
"machine learning": "机器学习能力",
"open-source and free": "开源与社区生态",
"robust": "生产可用性",
"short": "低样板代码",
"simple and pythonic": "Pythonic 开发体验",
"standards-based": "标准兼容性",
"statistics": "统计方法基础",
"visual studio code": "编辑器产品定位",
}
NOISY_FEATURE_TERMS = {
"bundled extensions",
"citation",
"code of conduct",
"community cloud",
"contribute",
"development container",
"example",
"example models",
"example upgrade",
"sponsors",
"opinions",
"feedback",
"requirements",
"examples",
"fastapi conf",
"fastapi mini documentary",
"get inspired",
"license",
"installation",
"projects using transformers",
"quickstart",
"related projects",
"resources",
"the repository",
"when shouldn't i use transformers?",
"why should i use transformers?",
"why use langchain?",
}
LOW_VALUE_TOPICS = {
"ai",
"anthropic",
"chatgpt",
"community",
"developer-tools",
"deepagents",
"deepseek",
"enterprise",
"framework",
"gemini",
"gemma",
"glm",
"hacktoberfest",
"json",
"langchain",
"microsoft",
"open-source",
"openai",
"python",
"qwen",
"typescript",
}
PREFERRED_DIRECTORY_ORDER = {
"src": 120,
"fastapi": 120,
"sklearn": 120,
"frontend": 115,
"lib": 115,
"python": 115,
"extensions": 112,
"app": 110,
"core": 110,
"server": 105,
"models": 105,
"docs": 100,
"docs_src": 100,
"examples": 95,
"tests": 88,
"scripts": 80,
"proto": 78,
"build": 72,
"remote": 72,
}
def ensure_output_dirs() -> None:
KNOWLEDGE_PROMPTS_DIR.mkdir(parents=True, exist_ok=True)
KNOWLEDGE_OUTPUTS_DIR.mkdir(parents=True, exist_ok=True)
KNOWLEDGE_SCHEMA_DIR.mkdir(parents=True, exist_ok=True)
def load_normalized_records(normalized_dir: Path = NORMALIZED_DIR) -> list[tuple[Path, dict[str, Any]]]:
records: list[tuple[Path, dict[str, Any]]] = []
for path in sorted(normalized_dir.glob("*.json")):
payload = json.loads(path.read_text(encoding="utf-8"))
if isinstance(payload, dict):
records.append((path, payload))
return records
def build_output_stem(repo_name: str, repo_url: str) -> str:
if "github.com/" in repo_url:
owner_repo = repo_url.split("github.com/", maxsplit=1)[-1]
owner_repo = owner_repo.strip("/").replace("/", "__").lower()
return re.sub(r"[^a-z0-9._-]+", "-", owner_repo)
return re.sub(r"[^a-z0-9._-]+", "-", repo_name.lower())
def _strip_markdown(text: str) -> str:
text = re.sub(r"<!--.*?-->", "", text, flags=re.DOTALL)
cleaned = re.sub(r"!\[[^\]]*\]\([^)]+\)", "", text)
cleaned = re.sub(r"\[([^\]]+)\]\([^)]+\)", r"\1", cleaned)
cleaned = re.sub(r"<[^>]+>", "", cleaned)
cleaned = re.sub(r"`+", "", cleaned)
cleaned = re.sub(r"\s+", " ", cleaned)
return cleaned.strip()
def _clean_readme_for_summary(readme_text: str) -> str:
cleaned = re.sub(r"<!--.*?-->", "", readme_text, flags=re.DOTALL)
cleaned = re.sub(r"<picture\b.*?</picture>", "", cleaned, flags=re.DOTALL | re.IGNORECASE)
cleaned = re.sub(r"<svg\b.*?</svg>", "", cleaned, flags=re.DOTALL | re.IGNORECASE)
cleaned = re.sub(r"<div\b[^>]*align=[\"']?center[\"']?[^>]*>.*?</div>", "", cleaned, flags=re.DOTALL | re.IGNORECASE)
cleaned = re.sub(r"<p\b[^>]*align=[\"']?center[\"']?[^>]*>.*?</p>", "", cleaned, flags=re.DOTALL | re.IGNORECASE)
return cleaned
def _is_low_value_summary_line(line: str) -> bool:
lowered = line.lower().strip()
if not lowered:
return True
if lowered.startswith(("#", "|", "---", "===", ".. ")):
return True
if line.count("|") >= 3:
return True
if lowered.startswith(("copyright", "license", "all rights reserved")):
return True
if any(token in lowered for token in (" badge", "shields.io", "build status", "coverage")):
return True
if lowered in NOISY_FEATURE_TERMS:
return True
if len(line) < 30:
return True
return False
def extract_summary(readme_text: str) -> str:
preferred_keywords = (
" provides ",
" is a ",
" is an ",
" lets you ",
" enables ",
" framework",
" library",
" toolkit",
" platform",
)
candidates: list[str] = []
for paragraph in _clean_readme_for_summary(readme_text).split("\n\n"):
line = _strip_markdown(paragraph)
if _is_low_value_summary_line(line):
continue
candidates.append(line)
lowered = f" {line.lower()} "
if any(keyword in lowered for keyword in preferred_keywords):
return line[:320]
if candidates:
return candidates[0][:320]
return ""
def infer_repo_category(normalized_record: dict[str, Any]) -> str:
joined_text = " ".join(
[
str(normalized_record.get("primary_language") or ""),
" ".join(normalized_record.get("main_features", [])),
" ".join(normalized_record.get("metadata", {}).get("topics", [])),
str(normalized_record.get("readme_text") or "")[:5000],
]
).lower()
scores = {
"LLM 应用框架": 0,
"深度学习框架": 0,
"机器学习库": 0,
"数据应用框架": 0,
"Web 框架": 0,
"数据与工作流平台": 0,
"开发工具": 0,
}
keyword_groups = {
"LLM 应用框架": ("llm", "rag", "agent", "embedding", "prompt", "retrieval", "vector"),
"深度学习框架": ("deep learning", "tensor", "autograd", "neural", "training", "transformer"),
"机器学习库": ("machine learning", "classification", "regression", "clustering", "feature extraction", "estimator"),
"数据应用框架": ("data app", "data apps", "dashboard", "interactive web apps", "streamlit", "analytics app"),
"Web 框架": ("api", "web", "openapi", "asgi", "rest", "swagger", "pydantic", "server"),
"数据与工作流平台": ("workflow", "scheduler", "dag", "orchestration", "pipeline"),
"开发工具": ("editor", "ide", "extension", "developer", "debugger", "code editing"),
}
for category, keywords in keyword_groups.items():
for keyword in keywords:
if keyword in joined_text:
scores[category] += 1
topics = [topic.lower() for topic in normalized_record.get("metadata", {}).get("topics", [])]
if "fastapi" in topics or "openapi" in topics:
scores["Web 框架"] += 3
if any(topic in topics for topic in ("llm", "rag", "agent")):
scores["LLM 应用框架"] += 3
if any(topic in topics for topic in ("machine-learning", "scikit-learn")):
scores["机器学习库"] += 3
if "streamlit" in topics or "data-visualization" in topics:
scores["数据应用框架"] += 3
best_category = max(scores, key=scores.get)
if scores[best_category] == 0:
return "通用开源项目"
return best_category
def infer_learning_value(category: str, normalized_record: dict[str, Any]) -> str:
repo_name = normalized_record.get("repo_name", "")
language = normalized_record.get("primary_language", "")
return (
f"{repo_name} 适合作为 {category} 的学习样本,"
f"可以帮助理解 {language} 生态下的核心能力、工程组织方式以及真实项目的功能拆分。"
)
def _load_raw_record(repo_name: str, repo_url: str) -> dict[str, Any] | None:
stem = build_output_stem(repo_name, repo_url)
raw_path = RAW_DIR / f"{stem}.json"
if not raw_path.exists():
return None
payload = json.loads(raw_path.read_text(encoding="utf-8"))
return payload if isinstance(payload, dict) else None
def _score_directory_name(name: str, repo_name: str) -> int:
lower_name = name.lower()
score = PREFERRED_DIRECTORY_ORDER.get(lower_name, 40)
if lower_name == repo_name.lower():
score += 90
if lower_name.startswith("."):
score -= 120
if lower_name in {".github", ".circleci", ".binder", ".claude", ".codex", ".cursor", ".devcontainer", ".vscode"}:
score -= 60
if lower_name in {"wiki", "specs", "maint_tools", "build_tools", "e2e_playwright"}:
score -= 15
return score
def _normalize_point_key(text: str) -> str:
lowered = text.lower().strip()
lowered = lowered.replace("目录阅读", "")
lowered = re.sub(r"[-_\s]+", "", lowered)
lowered = re.sub(r"[^a-z0-9\u4e00-\u9fff]+", "", lowered)
return lowered
def _humanize_topic(topic_text: str) -> str:
normalized = topic_text.lower().strip()
if normalized in TOPIC_DISPLAY_MAP:
return TOPIC_DISPLAY_MAP[normalized]
if "-" in normalized:
parts = [part for part in normalized.split("-") if part]
return " ".join(part.capitalize() for part in parts)
return topic_text
def _feature_to_point(feature_text: str) -> dict[str, str]:
if ":" in feature_text:
raw_name, raw_detail = feature_text.split(":", maxsplit=1)
name_key = raw_name.strip().lower()
display_name = FEATURE_NAME_MAP.get(name_key, raw_name.strip())
detail = raw_detail.strip()
description = f"仓库强调这一能力,重点在于:{detail}"
return {
"name": display_name[:80],
"category": "核心能力",
"description": description[:220],
"importance": "高",
"evidence": f"README main_features: {feature_text}",
}
normalized = feature_text.lower().strip()
display_name = FEATURE_NAME_MAP.get(normalized, feature_text)
description = f"README 将这一项作为核心能力直接强调,适合作为理解仓库定位的第一优先点。"
return {
"name": display_name[:80],
"category": "核心能力",
"description": description[:220],
"importance": "高",
"evidence": f"README main_features: {feature_text}",
}
def extract_top_directories(normalized_record: dict[str, Any], limit: int = 8) -> list[str]:
repo_name = str(normalized_record.get("repo_name") or "")
repo_url = str(normalized_record.get("repo_url") or "")
raw_record = _load_raw_record(repo_name, repo_url)
directory_names: list[str] = []
if raw_record:
seen: set[str] = set()
for item in raw_record.get("tree_items", []):
if item.get("type") != "tree":
continue
path = str(item.get("path") or "")
top = path.split("/")[0].strip()
if not top or top in seen:
continue
seen.add(top)
directory_names.append(top)
else:
for line in str(normalized_record.get("directory_tree") or "").splitlines():
stripped = line.strip()
if line.startswith("├── ") or line.startswith("└── "):
directory_names.append(stripped[4:].strip())
ranked = sorted(
directory_names,
key=lambda name: (-_score_directory_name(name, repo_name), name.lower()),
)
visible_dirs = [name for name in ranked if not name.startswith(".")]
if visible_dirs:
return visible_dirs[:limit]
return ranked[:limit]
def infer_prerequisites(normalized_record: dict[str, Any], category: str) -> list[str]:
prerequisites: list[str] = []
language = str(normalized_record.get("primary_language") or "")
if language:
prerequisites.append(f"{language} 基础")
if category == "深度学习框架":
prerequisites.extend(["线性代数与张量基础", "深度学习基本概念"])
elif category == "机器学习库":
prerequisites.extend(["机器学习基本概念", "数据预处理与特征工程基础"])
elif category == "数据应用框架":
prerequisites.extend(["Python 数据处理基础", "Web 交互与可视化基础"])
elif category == "Web 框架":
prerequisites.extend(["HTTP 与 REST 基础", "后端服务开发基础"])
elif category == "LLM 应用框架":
prerequisites.extend(["Prompt 基础", "向量检索或 RAG 基础"])
elif category == "数据与工作流平台":
prerequisites.extend(["任务编排基础", "数据工程基本概念"])
elif category == "开发工具":
prerequisites.extend(["软件工程基础", "调试与插件机制基础"])
deduplicated: list[str] = []
for item in prerequisites:
if item not in deduplicated:
deduplicated.append(item)
return deduplicated[:6]
def build_learning_path(category: str, directories: list[str]) -> list[str]:
path = [
"先通读 README,明确项目解决的问题和核心定位",
"再结合目录结构定位入口文件、核心模块和示例代码",
"最后挑 1 到 2 个代表性模块深入阅读实现细节",
]
if category == "LLM 应用框架":
path.append("重点关注 Prompt、检索、工具调用或 Agent 相关模块")
elif category == "深度学习框架":
path.append("重点关注 Tensor、自动求导、模型组件和训练相关模块")
elif category == "机器学习库":
path.append("重点关注数据预处理、模型接口、训练评估和算法模块")
elif category == "数据应用框架":
path.append("重点关注页面组件、数据展示、交互逻辑和部署相关模块")
elif category == "Web 框架":
path.append("重点关注路由、请求处理、数据校验和文档生成相关模块")
if directories:
path.append(f"建议优先阅读目录:{', '.join(directories[:3])}")
return path[:5]
def build_knowledge_points(normalized_record: dict[str, Any]) -> list[dict[str, str]]:
points: list[dict[str, str]] = []
main_features = list(normalized_record.get("main_features", []))
top_directories = extract_top_directories(normalized_record)
category = infer_repo_category(normalized_record)
seen_names: set[str] = set()
def add_point(item: dict[str, str]) -> bool:
normalized_name = _normalize_point_key(item["name"])
if normalized_name in seen_names:
return False
seen_names.add(normalized_name)
points.append(item)
return len(points) >= MAX_KNOWLEDGE_POINTS
for feature in main_features:
feature_text = _strip_markdown(feature)
normalized_feature = feature_text.lower().strip(" .:-")
if not feature_text or normalized_feature in NOISY_FEATURE_TERMS:
continue
if len(feature_text) < 8:
continue
if add_point(_feature_to_point(feature_text)):
return points
topics = normalized_record.get("metadata", {}).get("topics", [])
topic_points_added = 0
for topic in topics:
if topic_points_added >= 5:
break
topic_text = _strip_markdown(str(topic))
if not topic_text:
continue
if topic_text.lower() in LOW_VALUE_TOPICS:
continue
topic_category = TOPIC_CATEGORY_MAP.get(topic_text.lower(), category)
display_topic = _humanize_topic(topic_text)
if add_point(
{
"name": display_topic[:80],
"category": topic_category,
"description": (
f"仓库主题标签明确指向“{display_topic}”方向,"
f"说明这部分能力在项目定位中占比较高,阅读时值得优先关注。"
)[:220],
"importance": "中",
"evidence": f"metadata.topics contains: {topic_text}",
}
):
return points
topic_points_added += 1
for directory in top_directories:
key = directory.lower()
mapped = DIRECTORY_CATEGORY_MAP.get(key)
if not mapped:
continue
if add_point(
{
"name": f"阅读 {directory} 目录",
"category": mapped,
"description": (
f"{directory} 目录通常承载与 {mapped} 相关的关键实现,"
f"适合作为进入源码细节时的优先切入点。"
)[:220],
"importance": "中",
"evidence": f"directory_tree contains top-level entry: {directory}",
}
):
return points
fallback_points = {
"LLM 应用框架": ["Prompt 设计", "检索链路", "工具调用", "Agent 编排"],
"深度学习框架": ["张量计算", "自动求导", "模型模块", "训练流程"],
"机器学习库": ["数据预处理", "模型接口", "训练评估", "算法实现"],
"数据应用框架": ["页面组件", "数据交互", "可视化展示", "应用部署"],
"Web 框架": ["路由与接口", "请求校验", "文档生成", "服务部署"],
"数据与工作流平台": ["任务编排", "调度机制", "执行器设计", "可观测性"],
"开发工具": ["编辑器扩展", "调试能力", "插件生态", "工程架构"],
}
for item in fallback_points.get(category, []):
if add_point(
{
"name": item,
"category": category,
"description": f"{item} 是理解这一类仓库实现思路时几乎都会遇到的核心主题,适合拿来建立整体认知。",
"importance": "中",
"evidence": f"inferred from repo_category: {category}",
}
):
return points
return points
def build_knowledge_preview(normalized_record: dict[str, Any]) -> dict[str, Any]:
category = infer_repo_category(normalized_record)
directories = extract_top_directories(normalized_record)
tags = [str(normalized_record.get("primary_language") or "")]
tags.extend(normalized_record.get("metadata", {}).get("topics", [])[:7])
tags = [tag for tag in tags if tag]
preview = {
"repo_name": normalized_record.get("repo_name", ""),
"repo_url": normalized_record.get("repo_url", ""),
"repo_category": category,
"summary": extract_summary(str(normalized_record.get("readme_text") or "")),
"learning_value": infer_learning_value(category, normalized_record),
"prerequisites": infer_prerequisites(normalized_record, category),
"knowledge_points": build_knowledge_points(normalized_record),
"suggested_learning_path": build_learning_path(category, directories),
"relevant_directories": directories,
"tags": tags[:8],
}
validate_knowledge_record(preview)
return preview
def write_json(path: Path, payload: dict[str, Any]) -> None:
path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
def run_prepare_knowledge_packets() -> list[dict[str, str]]:
ensure_output_dirs()
schema = build_knowledge_json_schema()
schema_path = KNOWLEDGE_SCHEMA_DIR / "repo_knowledge.schema.json"
write_json(schema_path, schema)
results: list[dict[str, str]] = []
for normalized_path, normalized_record in load_normalized_records():
stem = build_output_stem(
str(normalized_record.get("repo_name") or normalized_path.stem),
str(normalized_record.get("repo_url") or ""),
)
prompt_packet = build_prompt_packet(normalized_record, schema)
preview = build_knowledge_preview(normalized_record)
prompt_path = KNOWLEDGE_PROMPTS_DIR / f"{stem}.json"
preview_path = KNOWLEDGE_OUTPUTS_DIR / f"{stem}.json"
write_json(prompt_path, prompt_packet)
write_json(preview_path, preview)
results.append(
{
"repo_name": str(normalized_record.get("repo_name") or ""),
"prompt_packet_path": str(prompt_path),
"preview_output_path": str(preview_path),
"schema_path": str(schema_path),
}
)
return results
from typing import Any
def build_knowledge_json_schema() -> dict[str, Any]:
return {
"title": "repo_knowledge_extraction",
"type": "object",
"additionalProperties": False,
"required": [
"repo_name",
"repo_url",
"repo_category",
"summary",
"learning_value",
"prerequisites",
"knowledge_points",
"suggested_learning_path",
"relevant_directories",
"tags",
],
"properties": {
"repo_name": {"type": "string"},
"repo_url": {"type": "string"},
"repo_category": {"type": "string"},
"summary": {"type": "string"},
"learning_value": {"type": "string"},
"prerequisites": {
"type": "array",
"items": {"type": "string"},
},
"knowledge_points": {
"type": "array",
"items": {
"type": "object",
"additionalProperties": False,
"required": [
"name",
"category",
"description",
"importance",
"evidence",
],
"properties": {
"name": {"type": "string"},
"category": {"type": "string"},
"description": {"type": "string"},
"importance": {"type": "string"},
"evidence": {"type": "string"},
},
},
},
"suggested_learning_path": {
"type": "array",
"items": {"type": "string"},
},
"relevant_directories": {
"type": "array",
"items": {"type": "string"},
},
"tags": {
"type": "array",
"items": {"type": "string"},
},
},
}
def validate_knowledge_record(record: dict[str, Any]) -> None:
required_fields = {
"repo_name": str,
"repo_url": str,
"repo_category": str,
"summary": str,
"learning_value": str,
"prerequisites": list,
"knowledge_points": list,
"suggested_learning_path": list,
"relevant_directories": list,
"tags": list,
}
for field_name, expected_type in required_fields.items():
if field_name not in record:
raise ValueError(f"Missing required field: {field_name}")
if not isinstance(record[field_name], expected_type):
raise TypeError(f"Field {field_name} must be {expected_type.__name__}")
for field_name in ("prerequisites", "suggested_learning_path", "relevant_directories", "tags"):
if not all(isinstance(item, str) for item in record[field_name]):
raise TypeError(f"All items in {field_name} must be strings")
for item in record["knowledge_points"]:
if not isinstance(item, dict):
raise TypeError("Each knowledge point must be an object")
for key in ("name", "category", "description", "importance", "evidence"):
if key not in item or not isinstance(item[key], str) or not item[key].strip():
raise ValueError(f"Invalid knowledge point field: {key}")
import base64
import importlib.util
import re
import sys
from pathlib import Path
from typing import Any
try:
from schemas import NormalizedRepoMetadata, NormalizedRepoRecord, RawRepoRecord
except ImportError:
CURRENT_DIR = Path(__file__).resolve().parent
if str(CURRENT_DIR) not in sys.path:
sys.path.insert(0, str(CURRENT_DIR))
schema_spec = importlib.util.spec_from_file_location(
"repo_ingestion_schemas",
CURRENT_DIR / "schemas.py",
)
if schema_spec is None or schema_spec.loader is None:
raise ImportError("Unable to load local schemas.py")
schema_module = importlib.util.module_from_spec(schema_spec)
schema_spec.loader.exec_module(schema_module)
NormalizedRepoMetadata = schema_module.NormalizedRepoMetadata
NormalizedRepoRecord = schema_module.NormalizedRepoRecord
RawRepoRecord = schema_module.RawRepoRecord
MAX_TREE_LINES = 300
MAX_MAIN_FEATURES = 8
FEATURE_SECTION_KEYWORDS = (
"feature",
"features",
"highlight",
"highlights",
"key features",
"why choose streamlit?",
)
INLINE_FEATURE_MARKERS = (
"features:",
"features are:",
"key features are:",
"high-level features:",
"following components:",
"used either as:",
"why choose",
)
GENERIC_HEADINGS = {
"installation",
"install",
"usage",
"quickstart",
"quick start",
"getting started",
"contributing",
"license",
"community",
"documentation",
"docs",
}
NOISY_HEADINGS = {
"sponsors",
"opinions",
"fastapi conf",
"fastapi mini documentary",
"resources",
"community cloud",
"get inspired",
"contribute",
"license",
"requirements",
"example",
"example upgrade",
"what is streamlit?",
}
NOISY_FEATURES = {
"sponsors",
"opinions",
"fastapi conf",
"fastapi mini documentary",
"resources",
"community cloud",
"requirements",
"example",
"example upgrade",
}
def decode_readme_content(encoded_content: str) -> str:
if not encoded_content:
return ""
compact_content = "".join(encoded_content.splitlines())
try:
decoded_bytes = base64.b64decode(compact_content, validate=False)
except Exception:
return encoded_content
return decoded_bytes.decode("utf-8", errors="replace").strip()
def _insert_path(tree: dict[str, Any], path: str, item_type: str) -> None:
parts = [part for part in path.split("/") if part]
if not parts:
return
current = tree
for part in parts[:-1]:
current = current.setdefault(part, {})
current[parts[-1]] = {} if item_type == "tree" else None
def _render_tree_lines(tree: dict[str, Any], prefix: str = "") -> list[str]:
lines: list[str] = []
keys = sorted(tree.keys(), key=lambda name: (tree[name] is None, name.lower()))
for index, key in enumerate(keys):
is_last = index == len(keys) - 1
connector = "└── " if is_last else "├── "
lines.append(f"{prefix}{connector}{key}")
child = tree[key]
if isinstance(child, dict) and child:
child_prefix = f"{prefix}{' ' if is_last else '│ '}"
lines.extend(_render_tree_lines(child, child_prefix))
return lines
def build_directory_tree(tree_items: list[dict[str, Any]], max_lines: int = MAX_TREE_LINES) -> str:
if not tree_items:
return ""
tree: dict[str, Any] = {}
for item in tree_items:
path = str(item.get("path") or "").strip()
item_type = str(item.get("type") or "blob").strip()
if not path:
continue
_insert_path(tree, path, item_type)
lines = _render_tree_lines(tree)
if not lines:
return ""
if len(lines) > max_lines:
remaining = len(lines) - max_lines
lines = lines[:max_lines]
lines.append(f"... ({remaining} more entries omitted)")
return "\n".join(lines)
def _normalize_feature_text(text: str) -> str:
cleaned = text.strip()
cleaned = re.sub(r"^[\-\*\+\d\.\)\s]+", "", cleaned)
cleaned = re.sub(r"\[([^\]]+)\]\([^)]+\)", r"\1", cleaned)
cleaned = re.sub(r"<[^>]+>", "", cleaned)
cleaned = re.sub(r"\*+", "", cleaned)
cleaned = re.sub(r"`+", "", cleaned)
cleaned = re.sub(r"\s+", " ", cleaned)
return cleaned.strip(" :.-")
def _is_noisy_feature(feature: str) -> bool:
normalized = feature.lower().strip(" .:-")
if normalized in NOISY_FEATURES:
return True
if len(normalized) < 6:
return True
if normalized.startswith("what is "):
return True
return False
def _extract_intro_sentences(readme_text: str, topics: list[str], limit: int) -> list[str]:
features: list[str] = []
paragraphs = [part.strip() for part in readme_text.split("\n\n") if part.strip()]
for paragraph in paragraphs[:12]:
if paragraph.startswith("#") or paragraph.startswith("##"):
continue
if paragraph.startswith(".. ") or paragraph.startswith("|"):
continue
if "image::" in paragraph or ":target:" in paragraph:
continue
cleaned = _normalize_feature_text(paragraph)
if not cleaned or len(cleaned) < 40:
continue
if "installation" in cleaned.lower() or "contributing" in cleaned.lower():
continue
if cleaned.count("|") >= 2:
continue
first_sentence = re.split(r"(?<=[.!?])\s+", cleaned, maxsplit=1)[0].strip()
if first_sentence and first_sentence not in features:
features.append(first_sentence[:180])
if len(features) >= limit:
return features
for topic in topics:
topic_text = topic.replace("-", " ").strip()
if not topic_text:
continue
candidate = topic_text[:1].upper() + topic_text[1:]
if candidate not in features:
features.append(candidate)
if len(features) >= limit:
break
return features
def extract_main_features(readme_text: str, topics: list[str] | None = None, limit: int = MAX_MAIN_FEATURES) -> list[str]:
if not readme_text:
return []
topic_list = topics or []
lines = readme_text.splitlines()
features: list[str] = []
collecting = False
for raw_line in lines:
line = raw_line.strip()
lower_line = line.lower().strip("# ").strip()
if line.startswith("#"):
collecting = lower_line in FEATURE_SECTION_KEYWORDS
continue
if any(marker in lower_line for marker in INLINE_FEATURE_MARKERS):
collecting = True
continue
if collecting and re.match(r"^[-*+]\s+.+", line):
candidate = _normalize_feature_text(line)
if candidate and not _is_noisy_feature(candidate) and candidate not in features:
features.append(candidate)
if len(features) >= limit:
return features
continue
if collecting and line:
collecting = False
if features:
return features
for raw_line in lines:
line = raw_line.strip()
if not line.startswith("## "):
continue
heading = _normalize_feature_text(line.lstrip("#"))
if not heading:
continue
lower_heading = heading.lower()
if lower_heading in GENERIC_HEADINGS or lower_heading in NOISY_HEADINGS:
continue
if heading not in features:
features.append(heading)
if len(features) >= limit:
break
if features:
return features
return _extract_intro_sentences(readme_text, topic_list, limit)
def normalize_repo_record(raw_record: RawRepoRecord) -> NormalizedRepoRecord:
readme_text = decode_readme_content(raw_record["readme_text"])
metadata = NormalizedRepoMetadata(
owner=raw_record["owner"],
default_branch=raw_record["default_branch"],
topics=list(raw_record["topics"]),
)
return NormalizedRepoRecord(
repo_name=raw_record["repo_name"],
repo_url=raw_record["repo_url"],
stars=raw_record["stars"],
primary_language=raw_record["primary_language"],
updated_at=raw_record["updated_at"],
readme_text=readme_text,
directory_tree=build_directory_tree(raw_record["tree_items"]),
main_features=extract_main_features(readme_text, topics=list(raw_record["topics"])),
metadata=metadata,
)
import json
import re
import sys
from pathlib import Path
from typing import Any
try:
from collector import collect_single_repo
from config import CANDIDATES_FILE, NORMALIZED_OUTPUT_DIR, RAW_OUTPUT_DIR
from parser import normalize_repo_record
from schemas import NormalizedRepoRecord, RawRepoRecord, RepoCandidate
except ImportError:
CURRENT_DIR = Path(__file__).resolve().parent
if str(CURRENT_DIR) not in sys.path:
sys.path.insert(0, str(CURRENT_DIR))
from collector import collect_single_repo
from config import CANDIDATES_FILE, NORMALIZED_OUTPUT_DIR, RAW_OUTPUT_DIR
from parser import normalize_repo_record
from schemas import NormalizedRepoRecord, RawRepoRecord, RepoCandidate
def ensure_output_dirs() -> None:
RAW_OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
NORMALIZED_OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
def load_candidates(candidates_file: Path = CANDIDATES_FILE) -> list[RepoCandidate]:
payload = json.loads(candidates_file.read_text(encoding="utf-8"))
if not isinstance(payload, list):
raise ValueError("candidates.json must contain a list.")
return [candidate for candidate in payload if isinstance(candidate, dict)]
def build_output_stem(owner: str, repo: str) -> str:
raw_stem = f"{owner}__{repo}".strip().lower()
return re.sub(r"[^a-z0-9._-]+", "-", raw_stem)
def write_json(path: Path, payload: dict[str, Any]) -> None:
path.write_text(
json.dumps(payload, ensure_ascii=False, indent=2),
encoding="utf-8",
)
def process_candidate(
candidate: RepoCandidate,
client: Any = None,
) -> tuple[RawRepoRecord, NormalizedRepoRecord]:
raw_record = collect_single_repo(candidate, client=client)
normalized_record = normalize_repo_record(raw_record)
return raw_record, normalized_record
def write_repo_outputs(raw_record: RawRepoRecord, normalized_record: NormalizedRepoRecord) -> tuple[Path, Path]:
ensure_output_dirs()
stem = build_output_stem(raw_record["owner"], raw_record["repo_name"])
raw_path = RAW_OUTPUT_DIR / f"{stem}.json"
normalized_path = NORMALIZED_OUTPUT_DIR / f"{stem}.json"
write_json(raw_path, raw_record)
write_json(normalized_path, normalized_record)
return raw_path, normalized_path
def run_batch_collect(
candidates: list[RepoCandidate],
client: Any = None,
) -> list[dict[str, str]]:
results: list[dict[str, str]] = []
for candidate in candidates:
raw_record, normalized_record = process_candidate(candidate, client=client)
raw_path, normalized_path = write_repo_outputs(raw_record, normalized_record)
results.append(
{
"repo_name": raw_record["repo_name"],
"raw_path": str(raw_path),
"normalized_path": str(normalized_path),
}
)
return results
import json
import re
from typing import Any
MAX_README_CHARS = 12000
MAX_TREE_LINES = 120
def _strip_markdown_noise(text: str) -> str:
cleaned = re.sub(r"!\[[^\]]*\]\([^)]+\)", "", text)
cleaned = re.sub(r"<img[^>]*>", "", cleaned)
cleaned = re.sub(r"<picture>.*?</picture>", "", cleaned, flags=re.DOTALL)
cleaned = re.sub(r"`{3}.*?`{3}", "", cleaned, flags=re.DOTALL)
cleaned = re.sub(r"\n{3,}", "\n\n", cleaned)
return cleaned.strip()
def build_prompt_context(normalized_record: dict[str, Any]) -> dict[str, Any]:
readme_text = _strip_markdown_noise(str(normalized_record.get("readme_text") or ""))
directory_tree = str(normalized_record.get("directory_tree") or "")
tree_lines = directory_tree.splitlines()[:MAX_TREE_LINES]
return {
"repo_name": normalized_record.get("repo_name", ""),
"repo_url": normalized_record.get("repo_url", ""),
"primary_language": normalized_record.get("primary_language", ""),
"stars": normalized_record.get("stars", 0),
"updated_at": normalized_record.get("updated_at", ""),
"main_features": normalized_record.get("main_features", []),
"metadata": normalized_record.get("metadata", {}),
"directory_tree_excerpt": "\n".join(tree_lines),
"readme_excerpt": readme_text[:MAX_README_CHARS],
}
def build_system_prompt() -> str:
return (
"你是一个负责分析 GitHub 开源仓库的技术研究助手。"
"你的任务是从 README、目录结构和仓库元信息中,提取适合后续培训、知识整理和项目分析使用的结构化知识点。"
"输出必须严格符合给定 JSON Schema,不要输出额外解释,不要输出 Markdown。"
"如果某个信息不能完全确定,可以基于 README 和目录结构做保守推断,但不要编造与仓库内容明显不符的信息。"
)
def build_user_prompt(normalized_record: dict[str, Any]) -> str:
context = build_prompt_context(normalized_record)
return (
"请基于下面的 GitHub 仓库信息,提取结构化知识点。\n\n"
"目标要求:\n"
"1. 判断仓库类别,例如深度学习框架、Web 框架、LLM 应用框架、开发工具、数据平台等。\n"
"2. 总结仓库的核心定位和学习价值。\n"
"3. 提炼 5 到 8 个值得学习的知识点,每个知识点都要附带来源证据。\n"
"4. 给出建议的前置知识和学习路径。\n"
"5. 标出最值得关注的目录。\n\n"
f"仓库名称:{context['repo_name']}\n"
f"仓库链接:{context['repo_url']}\n"
f"主要语言:{context['primary_language']}\n"
f"Stars:{context['stars']}\n"
f"最近更新时间:{context['updated_at']}\n"
f"main_features:{json.dumps(context['main_features'], ensure_ascii=False)}\n"
f"metadata:{json.dumps(context['metadata'], ensure_ascii=False)}\n\n"
"目录结构摘录:\n"
f"{context['directory_tree_excerpt']}\n\n"
"README 摘录:\n"
f"{context['readme_excerpt']}\n"
)
def build_prompt_packet(normalized_record: dict[str, Any], schema: dict[str, Any]) -> dict[str, Any]:
return {
"repo_name": normalized_record.get("repo_name", ""),
"repo_url": normalized_record.get("repo_url", ""),
"messages": [
{"role": "system", "content": build_system_prompt()},
{"role": "user", "content": build_user_prompt(normalized_record)},
],
"json_schema": schema,
}
import json
import re
import sys
from pathlib import Path
from typing import Any
try:
from github_client import GitHubClient
from schemas import RepoCandidate, RepoRecommendation, RepoSearchRequest
except ImportError:
CURRENT_DIR = Path(__file__).resolve().parent
if str(CURRENT_DIR) not in sys.path:
sys.path.insert(0, str(CURRENT_DIR))
from github_client import GitHubClient
from schemas import RepoCandidate, RepoRecommendation, RepoSearchRequest
DEFAULT_LIMIT = 10
DEFAULT_MIN_STARS = 100
MAX_GITHUB_SEARCH_PAGE_SIZE = 100
LOW_RELEVANCE_HINTS = {
"awesome",
"course",
"demo",
"example",
"examples",
"learn",
"sample",
"samples",
"template",
"tutorial",
"workshop",
}
def normalize_keywords(raw_keywords: list[str] | str) -> list[str]:
if isinstance(raw_keywords, str):
pieces = re.split(r"[,,\s]+", raw_keywords)
else:
pieces = []
for keyword in raw_keywords:
pieces.extend(re.split(r"[,,\s]+", str(keyword)))
result: list[str] = []
for piece in pieces:
keyword = piece.strip().lower()
if keyword and keyword not in result:
result.append(keyword)
return result
def build_github_search_query(request: RepoSearchRequest) -> str:
keywords = normalize_keywords(request.get("keywords", []))
if not keywords:
raise ValueError("At least one keyword is required for GitHub repository search.")
query_parts = keywords[:]
language = str(request.get("language") or "").strip()
if language:
query_parts.append(f"language:{language}")
min_stars = int(request.get("min_stars") or DEFAULT_MIN_STARS)
if min_stars > 0:
query_parts.append(f"stars:>{min_stars}")
updated_after = str(request.get("updated_after") or "").strip()
if updated_after:
query_parts.append(f"pushed:>{updated_after}")
query_parts.append("archived:false")
return " ".join(query_parts)
def _keyword_hit_count(text: str, keywords: list[str]) -> int:
lower_text = text.lower()
return sum(1 for keyword in keywords if keyword in lower_text)
def _semantic_hit_count(repo_item: dict[str, Any], keywords: list[str]) -> int:
semantic_text = " ".join(
[
str(repo_item.get("description") or ""),
" ".join(repo_item.get("topics") or []),
]
)
return _keyword_hit_count(semantic_text, keywords)
def _required_semantic_hits(keywords: list[str]) -> int:
if len(keywords) <= 1:
return 1
return min(2, len(keywords))
def _low_relevance_hint_hits(repo_item: dict[str, Any], keywords: list[str]) -> list[str]:
if any(keyword in LOW_RELEVANCE_HINTS for keyword in keywords):
return []
text = " ".join(
[
str(repo_item.get("name") or ""),
str(repo_item.get("full_name") or ""),
str(repo_item.get("description") or ""),
" ".join(repo_item.get("topics") or []),
]
).lower()
tokens = {token for token in re.split(r"[^a-z0-9]+", text) if token}
return sorted(LOW_RELEVANCE_HINTS & tokens)
def _is_semantically_relevant(repo_item: dict[str, Any], keywords: list[str]) -> bool:
return _semantic_hit_count(repo_item, keywords) >= _required_semantic_hits(keywords)
def _score_repo(repo_item: dict[str, Any], keywords: list[str], language: str) -> tuple[float, list[str]]:
name_text = " ".join(
[
str(repo_item.get("name") or ""),
str(repo_item.get("full_name") or ""),
]
)
description_text = str(repo_item.get("description") or "")
topics = repo_item.get("topics") or []
topics_text = " ".join(topics)
name_hits = _keyword_hit_count(name_text, keywords)
description_hits = _keyword_hit_count(description_text, keywords)
topic_hits = _keyword_hit_count(topics_text, keywords)
semantic_hits = _keyword_hit_count(f"{description_text} {topics_text}", keywords)
keyword_count = max(len(keywords), 1)
semantic_score = min(semantic_hits / keyword_count, 1.0) * 45
description_score = min(description_hits / keyword_count, 1.0) * 15
topic_score = min(topic_hits / keyword_count, 1.0) * 20
name_score = min(name_hits / keyword_count, 1.0) * 5
repo_language = str(repo_item.get("language") or "")
language_score = 10 if language and repo_language.lower() == language.lower() else 0
stars = int(repo_item.get("stargazers_count") or 0)
stars_score = min(stars / 20000, 1.0) * 10
low_relevance_hints = _low_relevance_hint_hits(repo_item, keywords)
low_relevance_penalty = 15 if low_relevance_hints else 0
score = round(
max(
semantic_score
+ description_score
+ topic_score
+ name_score
+ language_score
+ stars_score
- low_relevance_penalty,
0,
),
2,
)
reasons: list[str] = []
if semantic_hits:
reasons.append(f"仓库描述或 topics 命中 {semantic_hits} 个关键词")
if name_hits:
reasons.append(f"仓库名称命中 {name_hits} 个关键词")
if language_score:
reasons.append(f"主要语言为 {repo_language},符合语言筛选条件")
if stars:
reasons.append(f"GitHub stars 为 {stars},作为辅助排序因素")
if topic_hits:
reasons.append("仓库 topics 与搜索关键词存在交集")
if low_relevance_hints:
reasons.append(f"检测到偏教程或示例类信号,已降权:{', '.join(low_relevance_hints[:3])}")
if repo_item.get("updated_at"):
reasons.append(f"最近更新时间:{repo_item['updated_at']}")
return score, reasons
def _to_owner_repo(repo_item: dict[str, Any]) -> tuple[str, str]:
full_name = str(repo_item.get("full_name") or "")
if "/" not in full_name:
raise ValueError(f"Invalid GitHub full_name: {full_name}")
owner, repo = full_name.split("/", maxsplit=1)
return owner, repo
def search_repositories(
request: RepoSearchRequest,
client: GitHubClient | None = None,
) -> list[RepoRecommendation]:
github_client = client or GitHubClient()
limit = int(request.get("limit") or DEFAULT_LIMIT)
per_page = min(max(limit * 4, 20), MAX_GITHUB_SEARCH_PAGE_SIZE)
query = build_github_search_query(request)
payload = github_client.search_repositories(query=query, per_page=per_page)
items = payload.get("items", [])
if not isinstance(items, list):
return []
keywords = normalize_keywords(request.get("keywords", []))
language = str(request.get("language") or "")
recommendations: list[RepoRecommendation] = []
for item in items:
if not isinstance(item, dict):
continue
if item.get("fork") or item.get("archived"):
continue
if not _is_semantically_relevant(item, keywords):
continue
owner, repo = _to_owner_repo(item)
score, reasons = _score_repo(item, keywords, language)
recommendations.append(
RepoRecommendation(
owner=owner,
repo=repo,
repo_url=str(item.get("html_url") or f"https://github.com/{owner}/{repo}"),
description=str(item.get("description") or ""),
stars=int(item.get("stargazers_count") or 0),
primary_language=str(item.get("language") or ""),
topics=list(item.get("topics") or []),
updated_at=str(item.get("updated_at") or ""),
match_score=score,
recommend_reasons=reasons,
)
)
recommendations.sort(key=lambda item: item["match_score"], reverse=True)
return recommendations[:limit]
def recommendations_to_candidates(recommendations: list[RepoRecommendation]) -> list[RepoCandidate]:
return [
RepoCandidate(
owner=item["owner"],
repo=item["repo"],
repo_url=item["repo_url"],
)
for item in recommendations
]
def write_search_outputs(
recommendations: list[RepoRecommendation],
output_dir: Path,
stem: str,
) -> tuple[Path, Path]:
output_dir.mkdir(parents=True, exist_ok=True)
recommendations_path = output_dir / f"{stem}_recommendations.json"
candidates_path = output_dir / f"{stem}_candidates.json"
recommendations_path.write_text(
json.dumps(recommendations, ensure_ascii=False, indent=2),
encoding="utf-8",
)
candidates_path.write_text(
json.dumps(recommendations_to_candidates(recommendations), ensure_ascii=False, indent=2),
encoding="utf-8",
)
return recommendations_path, candidates_path
import argparse
import json
import sys
from pathlib import Path
try:
from pipeline import load_candidates, run_batch_collect
except ImportError:
CURRENT_DIR = Path(__file__).resolve().parent
if str(CURRENT_DIR) not in sys.path:
sys.path.insert(0, str(CURRENT_DIR))
from pipeline import load_candidates, run_batch_collect
def parse_args() -> argparse.Namespace:
parser = argparse.ArgumentParser(description="Collect GitHub repo README and tree data.")
parser.add_argument(
"--limit",
type=int,
default=1,
help="Number of repositories to collect from candidates.json.",
)
parser.add_argument(
"--candidates-file",
default="",
help="Optional candidates JSON file generated by run_search.py.",
)
return parser.parse_args()
def main() -> int:
args = parse_args()
candidates_file = Path(args.candidates_file) if args.candidates_file else None
candidates = load_candidates(candidates_file) if candidates_file else load_candidates()
if args.limit > 0:
candidates = candidates[: args.limit]
results = run_batch_collect(candidates)
print(json.dumps(results, ensure_ascii=False, indent=2))
return 0
if __name__ == "__main__":
raise SystemExit(main())
import json
import sys
from pathlib import Path
try:
from knowledge_pipeline import run_prepare_knowledge_packets
except ImportError:
CURRENT_DIR = Path(__file__).resolve().parent
if str(CURRENT_DIR) not in sys.path:
sys.path.insert(0, str(CURRENT_DIR))
from knowledge_pipeline import run_prepare_knowledge_packets
def main() -> int:
results = run_prepare_knowledge_packets()
print(json.dumps(results, ensure_ascii=False, indent=2))
return 0
if __name__ == "__main__":
raise SystemExit(main())
import argparse
import json
import re
import sys
from pathlib import Path
try:
from config import DATA_DIR
from recommender import search_repositories, write_search_outputs
from schemas import RepoSearchRequest
except ImportError:
CURRENT_DIR = Path(__file__).resolve().parent
if str(CURRENT_DIR) not in sys.path:
sys.path.insert(0, str(CURRENT_DIR))
from config import DATA_DIR
from recommender import search_repositories, write_search_outputs
from schemas import RepoSearchRequest
def _build_stem(keywords: str, language: str) -> str:
raw = "_".join(part for part in [keywords, language] if part).lower()
return re.sub(r"[^a-z0-9._-]+", "-", raw).strip("-") or "github_search"
def parse_args() -> argparse.Namespace:
parser = argparse.ArgumentParser(description="Search GitHub repositories by keywords.")
parser.add_argument("--keywords", required=True, help="Search keywords, e.g. 'rag harness'.")
parser.add_argument("--language", default="", help="Optional GitHub language filter.")
parser.add_argument("--min-stars", type=int, default=100, help="Minimum GitHub stars.")
parser.add_argument("--updated-after", default="", help="Optional pushed-after date, e.g. 2025-01-01.")
parser.add_argument("--limit", type=int, default=10, help="Number of repositories to recommend.")
parser.add_argument("--write", action="store_true", help="Write recommendations and candidates JSON files.")
return parser.parse_args()
def main() -> int:
args = parse_args()
request = RepoSearchRequest(
keywords=[args.keywords],
language=args.language,
min_stars=args.min_stars,
updated_after=args.updated_after,
limit=args.limit,
)
recommendations = search_repositories(request)
result: dict[str, object] = {"recommendations": recommendations}
if args.write:
stem = _build_stem(args.keywords, args.language)
output_dir = DATA_DIR / "search_results"
recommendations_path, candidates_path = write_search_outputs(recommendations, output_dir, stem)
result["recommendations_path"] = str(recommendations_path)
result["candidates_path"] = str(candidates_path)
print(json.dumps(result, ensure_ascii=False, indent=2))
return 0
if __name__ == "__main__":
raise SystemExit(main())
from typing import Any, TypedDict
class RepoCandidate(TypedDict):
owner: str
repo: str
repo_url: str
class RepoSearchRequest(TypedDict, total=False):
keywords: list[str]
language: str
min_stars: int
updated_after: str
limit: int
class RepoRecommendation(TypedDict):
owner: str
repo: str
repo_url: str
description: str
stars: int
primary_language: str
topics: list[str]
updated_at: str
match_score: float
recommend_reasons: list[str]
class RepoApiSource(TypedDict):
repo_api: str
readme_api: str
tree_api: str
class RawRepoRecord(TypedDict):
repo_name: str
owner: str
repo_url: str
description: str
stars: int
forks: int
watchers: int
primary_language: str
topics: list[str]
default_branch: str
updated_at: str
readme_text: str
tree_items: list[dict[str, Any]]
api_source: RepoApiSource
class NormalizedRepoMetadata(TypedDict):
owner: str
default_branch: str
topics: list[str]
class NormalizedRepoRecord(TypedDict):
repo_name: str
repo_url: str
stars: int
primary_language: str
updated_at: str
readme_text: str
directory_tree: str
main_features: list[str]
metadata: NormalizedRepoMetadata
# 今日任务规划:GitHub 热门仓库 README 与目录结构采集
> **日期**:2026-07-13
> **目标**:今天完成 5~10 个 GitHub 热门开源仓库的筛选与采集,拿到 README、目录结构、仓库基础信息,并为后续 `Prompt + JSON Schema` 结构化处理准备统一数据格式。
> **验收标准**:完成 5~10 个高质量仓库筛选;每个仓库具备 README、目录结构、stars、语言、更新时间、仓库链接;采集逻辑放入 `ai-service/`;采集结果统一落到 `shared/data/github_repos/`。
---
## 一、任务拆解
| 序号 | 任务项 | 说明 |
| --- | --- | --- |
| 1 | 明确筛选标准 | 定义“高质量热门仓库”的筛选条件 |
| 2 | 确定候选仓库池 | 先列出 10 个左右候选仓库 |
| 3 | 目录规划 | 明确代码落点和数据落点 |
| 4 | GitHub API 验证 | 验证仓库基础信息、README、目录结构是否可抓取 |
| 5 | 统一输出格式 | 明确 JSON 字段结构,避免后续返工 |
| 6 | 采集脚本实现 | 编写最小可用采集脚本 |
| 7 | 采集 5~10 个仓库 | 执行实际采集并保存结果 |
| 8 | 数据检查 | 校验字段是否完整、内容是否可用 |
| 9 | 结果整理 | 输出候选仓库清单与采集结果说明 |
| 10 | 后续接口准备 | 为 Prompt + JSON Schema 预留结构化输入格式 |
---
## 二、今日目录规划
按当前仓库约定执行:
```text
/home/admin2/studyweb/
├─ ai-service/
│ └─ repo_ingestion/
│ ├─ README.md
│ ├─ __init__.py
│ ├─ config.py
│ ├─ github_client.py
│ ├─ collector.py
│ ├─ parser.py
│ ├─ schemas.py
│ ├─ pipeline.py
│ └─ run_collect.py
├─ shared/
└─ data/
└─ github_repos/
├─ candidates.json
├─ raw/
├─ normalized/
└─ logs/
```
说明:
- `ai-service/`:放采集逻辑和后续 AI 处理入口
- `shared/data/github_repos/`:放采集结果
- `raw/`:原始抓取结果
- `normalized/`:统一结构后的结果,便于后续 Prompt / JSON Schema 使用
---
## 三、执行步骤
### 第一步:明确筛选标准
```text
□ 仓库必须为公开开源仓库
□ stars 需达到基本门槛
□ README 相对完整,不能只有几行
□ 目录结构清晰,不能完全不可读
□ 最近仍有更新,避免太旧的项目
□ 技术方向尽量和平台后续分析目标相关
```
### 第二步:确定候选仓库池
```text
□ 先列出 10 个左右候选仓库
□ 记录仓库名、链接、stars、语言、更新时间
□ 优先选 README 清晰、目录结构规整的仓库
□ 最终收敛到 5~10 个样本
```
### 第三步:统一输出格式
每个仓库建议至少包含以下字段:
```json
{
"repo_name": "",
"repo_url": "",
"stars": 0,
"primary_language": "",
"updated_at": "",
"readme_text": "",
"directory_tree": "",
"main_features": []
}
```
要求:
```text
□ 字段命名统一
□ README 保留原文
□ 目录结构尽量转成可读树形文本
□ 主要功能点先允许为空,后续可由 Prompt 结构化提取
```
### 第四步:GitHub API 验证
```text
□ 确认可以拿到仓库基础信息
□ 确认可以拿到 README 内容
□ 确认可以拿到目录结构相关数据
□ 确认 API 调用方式和限流情况
```
优先验证:
```text
1. 仓库基础信息接口
2. README 接口
3. 仓库树/目录结构接口
```
### 第五步:采集脚本实现
```text
□ 在 ai-service/repo_ingestion/ 下实现 GitHub API 调用逻辑
□ 将 README、目录结构、仓库元信息统一组装
□ 输出 raw JSON
□ 再做一层 normalized JSON
```
建议最小实现顺序:
```text
□ github_client.py:封装 API 请求
□ collector.py:按仓库清单批量采集
□ parser.py:把目录数据转成可读结构
□ schemas.py:定义统一输出字段
```
### 第六步:采集实际仓库样本
```text
□ 至少先跑通 1~2 个仓库,验证流程
□ 确认字段完整后,再扩到 5~10 个仓库
□ 原始结果落到 shared/data/github_repos/raw/
□ 标准化结果落到 shared/data/github_repos/normalized/
□ 候选仓库清单保存在 candidates.json
```
### 第七步:结果检查
```text
□ 每个仓库必须有 repo_url
□ 每个仓库必须有 stars
□ 每个仓库必须有 primary_language
□ 每个仓库必须有 updated_at
□ 每个仓库必须有 README
□ 每个仓库必须有目录结构
□ JSON 结构保持统一
```
### 第八步:为 Prompt + JSON Schema 做准备
```text
□ 保证 README 原文可直接作为 Prompt 输入
□ 保证目录结构字段可直接作为上下文补充
□ 保证 normalized 结果字段稳定,方便后续 JSON Schema 约束
□ main_features 字段预留给后续结构化抽取
```
---
## 四、验收检查单
```text
□ 已完成 5~10 个 GitHub 热门仓库筛选
□ 每个仓库的 README 已采集
□ 每个仓库的目录结构已采集
□ 每个仓库的 stars / language / updated_at / repo_url 已记录
□ 采集逻辑已放入 ai-service/
□ 采集结果已落到 shared/data/github_repos/
□ 原始结果与标准化结果已区分
□ 输出结构可直接供 Prompt + JSON Schema 使用
```
---
## 五、参考路径
- 平台架构文档:`/home/admin2/studyweb/平台文档/架构大纲.md`
- 今日任务规划文件:`/home/admin2/studyweb/ljy_docs/7-13+任务.md`
- 采集逻辑建议目录:`/home/admin2/studyweb/ai-service/repo_ingestion/`
- 采集结果建议目录:`/home/admin2/studyweb/shared/data/github_repos/`
---
## 六、若遇到阻塞
```text
□ GitHub API 限流 -> 检查是否需要 Token,降低请求频率
□ README 获取失败 -> 检查默认分支和 README 文件路径
□ 目录结构不完整 -> 检查 tree 接口返回层级和递归参数
□ 仓库太大 -> 先保留关键目录结构,不追求一次抓全全部细节
□ 字段不统一 -> 先收敛 schema,再批量重跑
□ main_features 难以人工总结 -> 先保留原始 README,后续交给 Prompt 提取
```
[
{
"owner": "pytorch",
"repo": "pytorch",
"repo_url": "https://github.com/pytorch/pytorch"
},
{
"owner": "fastapi",
"repo": "fastapi",
"repo_url": "https://github.com/fastapi/fastapi"
},
{
"owner": "langchain-ai",
"repo": "langchain",
"repo_url": "https://github.com/langchain-ai/langchain"
},
{
"owner": "microsoft",
"repo": "vscode",
"repo_url": "https://github.com/microsoft/vscode"
},
{
"owner": "huggingface",
"repo": "transformers",
"repo_url": "https://github.com/huggingface/transformers"
},
{
"owner": "scikit-learn",
"repo": "scikit-learn",
"repo_url": "https://github.com/scikit-learn/scikit-learn"
},
{
"owner": "streamlit",
"repo": "streamlit",
"repo_url": "https://github.com/streamlit/streamlit"
},
{
"owner": "vllm-project",
"repo": "vllm",
"repo_url": "https://github.com/vllm-project/vllm"
},
{
"owner": "run-llama",
"repo": "llama_index",
"repo_url": "https://github.com/run-llama/llama_index"
},
{
"owner": "apache",
"repo": "airflow",
"repo_url": "https://github.com/apache/airflow"
}
]
{
"repo_name": "airflow",
"repo_url": "https://github.com/apache/airflow",
"repo_category": "数据与工作流平台",
"summary": "Apache Airflow (or simply Airflow) is a platform to programmatically author, schedule, and monitor workflows.",
"learning_value": "airflow 适合作为 数据与工作流平台 的学习样本,可以帮助理解 Python 生态下的核心能力、工程组织方式以及真实项目的功能拆分。",
"prerequisites": [
"Python 基础",
"任务编排基础",
"数据工程基本概念"
],
"knowledge_points": [
{
"name": "Project Focus",
"category": "核心能力",
"description": "README 将这一项作为核心能力直接强调,适合作为理解仓库定位的第一优先点。",
"importance": "高",
"evidence": "README main_features: Project Focus"
},
{
"name": "Principles",
"category": "核心能力",
"description": "README 将这一项作为核心能力直接强调,适合作为理解仓库定位的第一优先点。",
"importance": "高",
"evidence": "README main_features: Principles"
},
{
"name": "Installing from PyPI",
"category": "核心能力",
"description": "README 将这一项作为核心能力直接强调,适合作为理解仓库定位的第一优先点。",
"importance": "高",
"evidence": "README main_features: Installing from PyPI"
},
{
"name": "Official source code",
"category": "核心能力",
"description": "README 将这一项作为核心能力直接强调,适合作为理解仓库定位的第一优先点。",
"importance": "高",
"evidence": "README main_features: Official source code"
},
{
"name": "Convenience packages",
"category": "核心能力",
"description": "README 将这一项作为核心能力直接强调,适合作为理解仓库定位的第一优先点。",
"importance": "高",
"evidence": "README main_features: Convenience packages"
},
{
"name": "User Interface",
"category": "核心能力",
"description": "README 将这一项作为核心能力直接强调,适合作为理解仓库定位的第一优先点。",
"importance": "高",
"evidence": "README main_features: User Interface"
},
{
"name": "Semantic versioning",
"category": "核心能力",
"description": "README 将这一项作为核心能力直接强调,适合作为理解仓库定位的第一优先点。",
"importance": "高",
"evidence": "README main_features: Semantic versioning"
},
{
"name": "Version Life Cycle",
"category": "核心能力",
"description": "README 将这一项作为核心能力直接强调,适合作为理解仓库定位的第一优先点。",
"importance": "高",
"evidence": "README main_features: Version Life Cycle"
}
],
"suggested_learning_path": [
"先通读 README,明确项目解决的问题和核心定位",
"再结合目录结构定位入口文件、核心模块和示例代码",
"最后挑 1 到 2 个代表性模块深入阅读实现细节",
"建议优先阅读目录:docs, scripts, airflow-core"
],
"relevant_directories": [
"docs",
"scripts",
"airflow-core",
"airflow-ctl",
"airflow-ctl-tests",
"airflow-e2e-tests",
"chart",
"clients"
],
"tags": [
"Python",
"airflow",
"apache",
"apache-airflow",
"automation",
"dag",
"data-engineering",
"data-integration"
]
}
\ No newline at end of file
{
"repo_name": "fastapi",
"repo_url": "https://github.com/fastapi/fastapi",
"repo_category": "Web 框架",
"summary": "FastAPI is a modern, fast (high-performance), web framework for building APIs with Python based on standard Python type hints.",
"learning_value": "fastapi 适合作为 Web 框架 的学习样本,可以帮助理解 Python 生态下的核心能力、工程组织方式以及真实项目的功能拆分。",
"prerequisites": [
"Python 基础",
"HTTP 与 REST 基础",
"后端服务开发基础"
],
"knowledge_points": [
{
"name": "高性能",
"category": "核心能力",
"description": "仓库强调这一能力,重点在于:Very high performance, on par with NodeJS and Go (thanks to Starlette and Pydantic). One of the fastest Python frameworks available",
"importance": "高",
"evidence": "README main_features: Fast: Very high performance, on par with NodeJS and Go (thanks to Starlette and Pydantic). One of the fastest Python frameworks available"
},
{
"name": "开发效率",
"category": "核心能力",
"description": "仓库强调这一能力,重点在于:Increase the speed to develop features by about 200% to 300%",
"importance": "高",
"evidence": "README main_features: Fast to code: Increase the speed to develop features by about 200% to 300%"
},
{
"name": "降低错误率",
"category": "核心能力",
"description": "仓库强调这一能力,重点在于:Reduce about 40% of human (developer) induced errors",
"importance": "高",
"evidence": "README main_features: Fewer bugs: Reduce about 40% of human (developer) induced errors"
},
{
"name": "编辑器友好",
"category": "核心能力",
"description": "仓库强调这一能力,重点在于:Great editor support. Completion everywhere. Less time debugging",
"importance": "高",
"evidence": "README main_features: Intuitive: Great editor support. Completion everywhere. Less time debugging"
},
{
"name": "低学习成本",
"category": "核心能力",
"description": "仓库强调这一能力,重点在于:Designed to be easy to use and learn. Less time reading docs",
"importance": "高",
"evidence": "README main_features: Easy: Designed to be easy to use and learn. Less time reading docs"
},
{
"name": "低样板代码",
"category": "核心能力",
"description": "仓库强调这一能力,重点在于:Minimize code duplication. Multiple features from each parameter declaration. Fewer bugs",
"importance": "高",
"evidence": "README main_features: Short: Minimize code duplication. Multiple features from each parameter declaration. Fewer bugs"
},
{
"name": "生产可用性",
"category": "核心能力",
"description": "仓库强调这一能力,重点在于:Get production-ready code. With automatic interactive documentation",
"importance": "高",
"evidence": "README main_features: Robust: Get production-ready code. With automatic interactive documentation"
},
{
"name": "标准兼容性",
"category": "核心能力",
"description": "仓库强调这一能力,重点在于:Based on (and fully compatible with) the open standards for APIs: OpenAPI (previously known as Swagger) and JSON Schema",
"importance": "高",
"evidence": "README main_features: Standards-based: Based on (and fully compatible with) the open standards for APIs: OpenAPI (previously known as Swagger) and JSON Schema"
}
],
"suggested_learning_path": [
"先通读 README,明确项目解决的问题和核心定位",
"再结合目录结构定位入口文件、核心模块和示例代码",
"最后挑 1 到 2 个代表性模块深入阅读实现细节",
"重点关注路由、请求处理、数据校验和文档生成相关模块",
"建议优先阅读目录:fastapi, docs, docs_src"
],
"relevant_directories": [
"fastapi",
"docs",
"docs_src",
"tests",
"scripts"
],
"tags": [
"Python",
"api",
"async",
"asyncio",
"fastapi",
"framework",
"json",
"json-schema"
]
}
\ No newline at end of file
{
"repo_name": "transformers",
"repo_url": "https://github.com/huggingface/transformers",
"repo_category": "LLM 应用框架",
"summary": "Transformers acts as the model-definition framework for state-of-the-art machine learning with text, computer vision, audio, video, and multimodal models, for both inference and training.",
"learning_value": "transformers 适合作为 LLM 应用框架 的学习样本,可以帮助理解 Python 生态下的核心能力、工程组织方式以及真实项目的功能拆分。",
"prerequisites": [
"Python 基础",
"Prompt 基础",
"向量检索或 RAG 基础"
],
"knowledge_points": [
{
"name": "音频模型能力",
"category": "多模态模型",
"description": "仓库主题标签明确指向“音频模型能力”方向,说明这部分能力在项目定位中占比较高,阅读时值得优先关注。",
"importance": "中",
"evidence": "metadata.topics contains: audio"
},
{
"name": "深度学习",
"category": "深度学习",
"description": "仓库主题标签明确指向“深度学习”方向,说明这部分能力在项目定位中占比较高,阅读时值得优先关注。",
"importance": "中",
"evidence": "metadata.topics contains: deep-learning"
},
{
"name": "大模型应用",
"category": "大模型应用",
"description": "仓库主题标签明确指向“大模型应用”方向,说明这部分能力在项目定位中占比较高,阅读时值得优先关注。",
"importance": "中",
"evidence": "metadata.topics contains: llm"
},
{
"name": "机器学习",
"category": "机器学习",
"description": "仓库主题标签明确指向“机器学习”方向,说明这部分能力在项目定位中占比较高,阅读时值得优先关注。",
"importance": "中",
"evidence": "metadata.topics contains: machine-learning"
},
{
"name": "模型仓库生态",
"category": "LLM 应用框架",
"description": "仓库主题标签明确指向“模型仓库生态”方向,说明这部分能力在项目定位中占比较高,阅读时值得优先关注。",
"importance": "中",
"evidence": "metadata.topics contains: model-hub"
},
{
"name": "阅读 src 目录",
"category": "核心源码",
"description": "src 目录通常承载与 核心源码 相关的关键实现,适合作为进入源码细节时的优先切入点。",
"importance": "中",
"evidence": "directory_tree contains top-level entry: src"
},
{
"name": "阅读 docs 目录",
"category": "文档体系",
"description": "docs 目录通常承载与 文档体系 相关的关键实现,适合作为进入源码细节时的优先切入点。",
"importance": "中",
"evidence": "directory_tree contains top-level entry: docs"
},
{
"name": "阅读 examples 目录",
"category": "示例用法",
"description": "examples 目录通常承载与 示例用法 相关的关键实现,适合作为进入源码细节时的优先切入点。",
"importance": "中",
"evidence": "directory_tree contains top-level entry: examples"
}
],
"suggested_learning_path": [
"先通读 README,明确项目解决的问题和核心定位",
"再结合目录结构定位入口文件、核心模块和示例代码",
"最后挑 1 到 2 个代表性模块深入阅读实现细节",
"重点关注 Prompt、检索、工具调用或 Agent 相关模块",
"建议优先阅读目录:src, docs, examples"
],
"relevant_directories": [
"src",
"docs",
"examples",
"tests",
"scripts",
"benchmark",
"benchmark_v2",
"docker"
],
"tags": [
"Python",
"audio",
"deep-learning",
"deepseek",
"gemma",
"glm",
"hacktoberfest",
"llm"
]
}
\ No newline at end of file
{
"repo_name": "langchain",
"repo_url": "https://github.com/langchain-ai/langchain",
"repo_category": "LLM 应用框架",
"summary": "LangChain is a framework for building agents and LLM-powered applications. It helps you chain together interoperable components and third-party integrations to simplify AI application development — all while future-proofing decisions as the underlying technology evolves.",
"learning_value": "langchain 适合作为 LLM 应用框架 的学习样本,可以帮助理解 Python 生态下的核心能力、工程组织方式以及真实项目的功能拆分。",
"prerequisites": [
"Python 基础",
"Prompt 基础",
"向量检索或 RAG 基础"
],
"knowledge_points": [
{
"name": "LangChain ecosystem",
"category": "核心能力",
"description": "README 将这一项作为核心能力直接强调,适合作为理解仓库定位的第一优先点。",
"importance": "高",
"evidence": "README main_features: LangChain ecosystem"
},
{
"name": "Agent 机制",
"category": "Agent 机制",
"description": "仓库主题标签明确指向“Agent 机制”方向,说明这部分能力在项目定位中占比较高,阅读时值得优先关注。",
"importance": "中",
"evidence": "metadata.topics contains: agents"
},
{
"name": "AI Agent 应用",
"category": "Agent 机制",
"description": "仓库主题标签明确指向“AI Agent 应用”方向,说明这部分能力在项目定位中占比较高,阅读时值得优先关注。",
"importance": "中",
"evidence": "metadata.topics contains: ai-agents"
},
{
"name": "生成式 AI 应用",
"category": "大模型应用",
"description": "仓库主题标签明确指向“生成式 AI 应用”方向,说明这部分能力在项目定位中占比较高,阅读时值得优先关注。",
"importance": "中",
"evidence": "metadata.topics contains: generative-ai"
},
{
"name": "LangGraph 编排",
"category": "Agent 编排",
"description": "仓库主题标签明确指向“LangGraph 编排”方向,说明这部分能力在项目定位中占比较高,阅读时值得优先关注。",
"importance": "中",
"evidence": "metadata.topics contains: langgraph"
},
{
"name": "大模型应用",
"category": "大模型应用",
"description": "仓库主题标签明确指向“大模型应用”方向,说明这部分能力在项目定位中占比较高,阅读时值得优先关注。",
"importance": "中",
"evidence": "metadata.topics contains: llm"
},
{
"name": "Prompt 设计",
"category": "LLM 应用框架",
"description": "Prompt 设计 是理解这一类仓库实现思路时几乎都会遇到的核心主题,适合拿来建立整体认知。",
"importance": "中",
"evidence": "inferred from repo_category: LLM 应用框架"
},
{
"name": "检索链路",
"category": "LLM 应用框架",
"description": "检索链路 是理解这一类仓库实现思路时几乎都会遇到的核心主题,适合拿来建立整体认知。",
"importance": "中",
"evidence": "inferred from repo_category: LLM 应用框架"
}
],
"suggested_learning_path": [
"先通读 README,明确项目解决的问题和核心定位",
"再结合目录结构定位入口文件、核心模块和示例代码",
"最后挑 1 到 2 个代表性模块深入阅读实现细节",
"重点关注 Prompt、检索、工具调用或 Agent 相关模块",
"建议优先阅读目录:libs"
],
"relevant_directories": [
"libs"
],
"tags": [
"Python",
"agents",
"ai",
"ai-agents",
"anthropic",
"chatgpt",
"deepagents",
"enterprise"
]
}
\ No newline at end of file
{
"repo_name": "vscode",
"repo_url": "https://github.com/microsoft/vscode",
"repo_category": "开发工具",
"summary": "Visual Studio Code is a distribution of the Code - OSS repository with Microsoft-specific customizations released under a traditional Microsoft product license.",
"learning_value": "vscode 适合作为 开发工具 的学习样本,可以帮助理解 TypeScript 生态下的核心能力、工程组织方式以及真实项目的功能拆分。",
"prerequisites": [
"TypeScript 基础",
"软件工程基础",
"调试与插件机制基础"
],
"knowledge_points": [
{
"name": "编辑器产品定位",
"category": "核心能力",
"description": "README 将这一项作为核心能力直接强调,适合作为理解仓库定位的第一优先点。",
"importance": "高",
"evidence": "README main_features: Visual Studio Code"
},
{
"name": "编辑器架构",
"category": "开发工具",
"description": "仓库主题标签明确指向“编辑器架构”方向,说明这部分能力在项目定位中占比较高,阅读时值得优先关注。",
"importance": "中",
"evidence": "metadata.topics contains: editor"
},
{
"name": "Electron 桌面壳",
"category": "开发工具",
"description": "仓库主题标签明确指向“Electron 桌面壳”方向,说明这部分能力在项目定位中占比较高,阅读时值得优先关注。",
"importance": "中",
"evidence": "metadata.topics contains: electron"
},
{
"name": "VS Code 生态",
"category": "开发工具",
"description": "仓库主题标签明确指向“VS Code 生态”方向,说明这部分能力在项目定位中占比较高,阅读时值得优先关注。",
"importance": "中",
"evidence": "metadata.topics contains: visual-studio-code"
},
{
"name": "阅读 src 目录",
"category": "核心源码",
"description": "src 目录通常承载与 核心源码 相关的关键实现,适合作为进入源码细节时的优先切入点。",
"importance": "中",
"evidence": "directory_tree contains top-level entry: src"
},
{
"name": "阅读 extensions 目录",
"category": "扩展机制",
"description": "extensions 目录通常承载与 扩展机制 相关的关键实现,适合作为进入源码细节时的优先切入点。",
"importance": "中",
"evidence": "directory_tree contains top-level entry: extensions"
},
{
"name": "阅读 scripts 目录",
"category": "工程脚本",
"description": "scripts 目录通常承载与 工程脚本 相关的关键实现,适合作为进入源码细节时的优先切入点。",
"importance": "中",
"evidence": "directory_tree contains top-level entry: scripts"
},
{
"name": "阅读 build 目录",
"category": "构建系统",
"description": "build 目录通常承载与 构建系统 相关的关键实现,适合作为进入源码细节时的优先切入点。",
"importance": "中",
"evidence": "directory_tree contains top-level entry: build"
}
],
"suggested_learning_path": [
"先通读 README,明确项目解决的问题和核心定位",
"再结合目录结构定位入口文件、核心模块和示例代码",
"最后挑 1 到 2 个代表性模块深入阅读实现细节",
"建议优先阅读目录:src, extensions, scripts"
],
"relevant_directories": [
"src",
"extensions",
"scripts",
"build",
"remote",
"cli",
"resources",
"test"
],
"tags": [
"TypeScript",
"editor",
"electron",
"microsoft",
"typescript",
"visual-studio-code"
]
}
\ No newline at end of file
{
"repo_name": "pytorch",
"repo_url": "https://github.com/pytorch/pytorch",
"repo_category": "深度学习框架",
"summary": "PyTorch is a Python package that provides two high-level features: - Tensor computation (like NumPy) with strong GPU acceleration - Deep neural networks built on a tape-based autograd system",
"learning_value": "pytorch 适合作为 深度学习框架 的学习样本,可以帮助理解 Python 生态下的核心能力、工程组织方式以及真实项目的功能拆分。",
"prerequisites": [
"Python 基础",
"线性代数与张量基础",
"深度学习基本概念"
],
"knowledge_points": [
{
"name": "Tensor computation (like NumPy) with strong GPU acceleration",
"category": "核心能力",
"description": "README 将这一项作为核心能力直接强调,适合作为理解仓库定位的第一优先点。",
"importance": "高",
"evidence": "README main_features: Tensor computation (like NumPy) with strong GPU acceleration"
},
{
"name": "Deep neural networks built on a tape-based autograd system",
"category": "核心能力",
"description": "README 将这一项作为核心能力直接强调,适合作为理解仓库定位的第一优先点。",
"importance": "高",
"evidence": "README main_features: Deep neural networks built on a tape-based autograd system"
},
{
"name": "A replacement for NumPy to use the power of GPUs",
"category": "核心能力",
"description": "README 将这一项作为核心能力直接强调,适合作为理解仓库定位的第一优先点。",
"importance": "高",
"evidence": "README main_features: A replacement for NumPy to use the power of GPUs"
},
{
"name": "A deep learning research platform that provides maximum flexibility and speed",
"category": "核心能力",
"description": "README 将这一项作为核心能力直接强调,适合作为理解仓库定位的第一优先点。",
"importance": "高",
"evidence": "README main_features: A deep learning research platform that provides maximum flexibility and speed"
},
{
"name": "autograd",
"category": "深度学习框架",
"description": "仓库主题标签明确指向“autograd”方向,说明这部分能力在项目定位中占比较高,阅读时值得优先关注。",
"importance": "中",
"evidence": "metadata.topics contains: autograd"
},
{
"name": "深度学习",
"category": "深度学习",
"description": "仓库主题标签明确指向“深度学习”方向,说明这部分能力在项目定位中占比较高,阅读时值得优先关注。",
"importance": "中",
"evidence": "metadata.topics contains: deep-learning"
},
{
"name": "gpu",
"category": "深度学习框架",
"description": "仓库主题标签明确指向“gpu”方向,说明这部分能力在项目定位中占比较高,阅读时值得优先关注。",
"importance": "中",
"evidence": "metadata.topics contains: gpu"
},
{
"name": "机器学习",
"category": "机器学习",
"description": "仓库主题标签明确指向“机器学习”方向,说明这部分能力在项目定位中占比较高,阅读时值得优先关注。",
"importance": "中",
"evidence": "metadata.topics contains: machine-learning"
}
],
"suggested_learning_path": [
"先通读 README,明确项目解决的问题和核心定位",
"再结合目录结构定位入口文件、核心模块和示例代码",
"最后挑 1 到 2 个代表性模块深入阅读实现细节",
"重点关注 Tensor、自动求导、模型组件和训练相关模块",
"建议优先阅读目录:docs, scripts, android"
],
"relevant_directories": [
"docs",
"scripts",
"android",
"aten",
"benchmarks",
"binaries",
"c10",
"caffe2"
],
"tags": [
"Python",
"autograd",
"deep-learning",
"gpu",
"machine-learning",
"neural-network",
"numpy",
"python"
]
}
\ No newline at end of file
{
"repo_name": "llama_index",
"repo_url": "https://github.com/run-llama/llama_index",
"repo_category": "LLM 应用框架",
"summary": "LlamaIndex OSS (by LlamaIndex) is an open-source framework to build agentic applications. **Parse** is our enterprise platform for agentic OCR, parsing, extraction, indexing and more. You can use LlamaParse with this framework or on its own; see LlamaParse below for signup and product links.",
"learning_value": "llama_index 适合作为 LLM 应用框架 的学习样本,可以帮助理解 Python 生态下的核心能力、工程组织方式以及真实项目的功能拆分。",
"prerequisites": [
"Python 基础",
"Prompt 基础",
"向量检索或 RAG 基础"
],
"knowledge_points": [
{
"name": "🚀 Overview",
"category": "核心能力",
"description": "README 将这一项作为核心能力直接强调,适合作为理解仓库定位的第一优先点。",
"importance": "高",
"evidence": "README main_features: 🚀 Overview"
},
{
"name": "💡 Contributing",
"category": "核心能力",
"description": "README 将这一项作为核心能力直接强调,适合作为理解仓库定位的第一优先点。",
"importance": "高",
"evidence": "README main_features: 💡 Contributing"
},
{
"name": "📄 Documentation",
"category": "核心能力",
"description": "README 将这一项作为核心能力直接强调,适合作为理解仓库定位的第一优先点。",
"importance": "高",
"evidence": "README main_features: 📄 Documentation"
},
{
"name": "💻 Example Usage",
"category": "核心能力",
"description": "README 将这一项作为核心能力直接强调,适合作为理解仓库定位的第一优先点。",
"importance": "高",
"evidence": "README main_features: 💻 Example Usage"
},
{
"name": "A note on Verification of Build Assets",
"category": "核心能力",
"description": "README 将这一项作为核心能力直接强调,适合作为理解仓库定位的第一优先点。",
"importance": "高",
"evidence": "README main_features: A note on Verification of Build Assets"
},
{
"name": "📖 Citation",
"category": "核心能力",
"description": "README 将这一项作为核心能力直接强调,适合作为理解仓库定位的第一优先点。",
"importance": "高",
"evidence": "README main_features: 📖 Citation"
},
{
"name": "Agent 机制",
"category": "Agent 机制",
"description": "仓库主题标签明确指向“Agent 机制”方向,说明这部分能力在项目定位中占比较高,阅读时值得优先关注。",
"importance": "中",
"evidence": "metadata.topics contains: agents"
},
{
"name": "application",
"category": "LLM 应用框架",
"description": "仓库主题标签明确指向“application”方向,说明这部分能力在项目定位中占比较高,阅读时值得优先关注。",
"importance": "中",
"evidence": "metadata.topics contains: application"
}
],
"suggested_learning_path": [
"先通读 README,明确项目解决的问题和核心定位",
"再结合目录结构定位入口文件、核心模块和示例代码",
"最后挑 1 到 2 个代表性模块深入阅读实现细节",
"重点关注 Prompt、检索、工具调用或 Agent 相关模块",
"建议优先阅读目录:docs, scripts, llama-dev"
],
"relevant_directories": [
"docs",
"scripts",
"llama-dev",
"llama-index-core",
"llama-index-instrumentation",
"llama-index-integrations",
"llama-index-utils"
],
"tags": [
"Python",
"agents",
"application",
"data",
"fine-tuning",
"framework",
"llamaindex",
"llm"
]
}
\ No newline at end of file
{
"repo_name": "scikit-learn",
"repo_url": "https://github.com/scikit-learn/scikit-learn",
"repo_category": "机器学习库",
"summary": "**scikit-learn** is a Python module for machine learning built on top of SciPy and is distributed under the 3-Clause BSD license.",
"learning_value": "scikit-learn 适合作为 机器学习库 的学习样本,可以帮助理解 Python 生态下的核心能力、工程组织方式以及真实项目的功能拆分。",
"prerequisites": [
"Python 基础",
"机器学习基本概念",
"数据预处理与特征工程基础"
],
"knowledge_points": [
{
"name": "Data analysis",
"category": "核心能力",
"description": "README 将这一项作为核心能力直接强调,适合作为理解仓库定位的第一优先点。",
"importance": "高",
"evidence": "README main_features: Data analysis"
},
{
"name": "Data science",
"category": "核心能力",
"description": "README 将这一项作为核心能力直接强调,适合作为理解仓库定位的第一优先点。",
"importance": "高",
"evidence": "README main_features: Data science"
},
{
"name": "机器学习能力",
"category": "核心能力",
"description": "README 将这一项作为核心能力直接强调,适合作为理解仓库定位的第一优先点。",
"importance": "高",
"evidence": "README main_features: Machine learning"
},
{
"name": "统计方法基础",
"category": "核心能力",
"description": "README 将这一项作为核心能力直接强调,适合作为理解仓库定位的第一优先点。",
"importance": "高",
"evidence": "README main_features: Statistics"
},
{
"name": "数据分析",
"category": "机器学习库",
"description": "仓库主题标签明确指向“数据分析”方向,说明这部分能力在项目定位中占比较高,阅读时值得优先关注。",
"importance": "中",
"evidence": "metadata.topics contains: data-analysis"
},
{
"name": "数据科学",
"category": "机器学习库",
"description": "仓库主题标签明确指向“数据科学”方向,说明这部分能力在项目定位中占比较高,阅读时值得优先关注。",
"importance": "中",
"evidence": "metadata.topics contains: data-science"
},
{
"name": "机器学习",
"category": "机器学习",
"description": "仓库主题标签明确指向“机器学习”方向,说明这部分能力在项目定位中占比较高,阅读时值得优先关注。",
"importance": "中",
"evidence": "metadata.topics contains: machine-learning"
},
{
"name": "统计建模",
"category": "机器学习库",
"description": "仓库主题标签明确指向“统计建模”方向,说明这部分能力在项目定位中占比较高,阅读时值得优先关注。",
"importance": "中",
"evidence": "metadata.topics contains: statistics"
}
],
"suggested_learning_path": [
"先通读 README,明确项目解决的问题和核心定位",
"再结合目录结构定位入口文件、核心模块和示例代码",
"最后挑 1 到 2 个代表性模块深入阅读实现细节",
"重点关注数据预处理、模型接口、训练评估和算法模块",
"建议优先阅读目录:sklearn, examples, asv_benchmarks"
],
"relevant_directories": [
"sklearn",
"examples",
"asv_benchmarks",
"benchmarks",
"doc",
"build_tools",
"maint_tools"
],
"tags": [
"Python",
"data-analysis",
"data-science",
"machine-learning",
"python",
"statistics"
]
}
\ No newline at end of file
{
"repo_name": "streamlit",
"repo_url": "https://github.com/streamlit/streamlit",
"repo_category": "数据应用框架",
"summary": "Streamlit lets you transform Python scripts into interactive web apps in minutes, instead of weeks. Build dashboards, generate reports, or create chat apps. Once you’ve created an app, you can use our Community Cloud platform to deploy, manage, and share your app.",
"learning_value": "streamlit 适合作为 数据应用框架 的学习样本,可以帮助理解 Python 生态下的核心能力、工程组织方式以及真实项目的功能拆分。",
"prerequisites": [
"Python 基础",
"Python 数据处理基础",
"Web 交互与可视化基础"
],
"knowledge_points": [
{
"name": "Pythonic 开发体验",
"category": "核心能力",
"description": "仓库强调这一能力,重点在于:Write beautiful, easy-to-read code",
"importance": "高",
"evidence": "README main_features: Simple and Pythonic: Write beautiful, easy-to-read code"
},
{
"name": "Fast, interactive prototyping",
"category": "核心能力",
"description": "仓库强调这一能力,重点在于:Let others interact with your data and provide feedback quickly",
"importance": "高",
"evidence": "README main_features: Fast, interactive prototyping: Let others interact with your data and provide feedback quickly"
},
{
"name": "实时编辑反馈",
"category": "核心能力",
"description": "仓库强调这一能力,重点在于:See your app update instantly as you edit your script",
"importance": "高",
"evidence": "README main_features: Live editing: See your app update instantly as you edit your script"
},
{
"name": "开源与社区生态",
"category": "核心能力",
"description": "仓库强调这一能力,重点在于:Join a vibrant community and contribute to Streamlit's future",
"importance": "高",
"evidence": "README main_features: Open-source and free: Join a vibrant community and contribute to Streamlit's future"
},
{
"name": "数据分析",
"category": "数据应用框架",
"description": "仓库主题标签明确指向“数据分析”方向,说明这部分能力在项目定位中占比较高,阅读时值得优先关注。",
"importance": "中",
"evidence": "metadata.topics contains: data-analysis"
},
{
"name": "数据科学",
"category": "数据应用框架",
"description": "仓库主题标签明确指向“数据科学”方向,说明这部分能力在项目定位中占比较高,阅读时值得优先关注。",
"importance": "中",
"evidence": "metadata.topics contains: data-science"
},
{
"name": "数据可视化",
"category": "数据应用框架",
"description": "仓库主题标签明确指向“数据可视化”方向,说明这部分能力在项目定位中占比较高,阅读时值得优先关注。",
"importance": "中",
"evidence": "metadata.topics contains: data-visualization"
},
{
"name": "深度学习",
"category": "深度学习",
"description": "仓库主题标签明确指向“深度学习”方向,说明这部分能力在项目定位中占比较高,阅读时值得优先关注。",
"importance": "中",
"evidence": "metadata.topics contains: deep-learning"
}
],
"suggested_learning_path": [
"先通读 README,明确项目解决的问题和核心定位",
"再结合目录结构定位入口文件、核心模块和示例代码",
"最后挑 1 到 2 个代表性模块深入阅读实现细节",
"重点关注页面组件、数据展示、交互逻辑和部署相关模块",
"建议优先阅读目录:frontend, lib, scripts"
],
"relevant_directories": [
"frontend",
"lib",
"scripts",
"proto",
"e2e_playwright",
"specs",
"wiki"
],
"tags": [
"Python",
"data-analysis",
"data-science",
"data-visualization",
"deep-learning",
"developer-tools",
"machine-learning",
"python"
]
}
\ No newline at end of file
{
"repo_name": "vllm",
"repo_url": "https://github.com/vllm-project/vllm",
"repo_category": "LLM 应用框架",
"summary": "vLLM is a fast and easy-to-use library for LLM inference and serving.",
"learning_value": "vllm 适合作为 LLM 应用框架 的学习样本,可以帮助理解 Python 生态下的核心能力、工程组织方式以及真实项目的功能拆分。",
"prerequisites": [
"Python 基础",
"Prompt 基础",
"向量检索或 RAG 基础"
],
"knowledge_points": [
{
"name": "Contact Us",
"category": "核心能力",
"description": "README 将这一项作为核心能力直接强调,适合作为理解仓库定位的第一优先点。",
"importance": "高",
"evidence": "README main_features: Contact Us"
},
{
"name": "Media Kit",
"category": "核心能力",
"description": "README 将这一项作为核心能力直接强调,适合作为理解仓库定位的第一优先点。",
"importance": "高",
"evidence": "README main_features: Media Kit"
},
{
"name": "amd",
"category": "LLM 应用框架",
"description": "仓库主题标签明确指向“amd”方向,说明这部分能力在项目定位中占比较高,阅读时值得优先关注。",
"importance": "中",
"evidence": "metadata.topics contains: amd"
},
{
"name": "blackwell",
"category": "LLM 应用框架",
"description": "仓库主题标签明确指向“blackwell”方向,说明这部分能力在项目定位中占比较高,阅读时值得优先关注。",
"importance": "中",
"evidence": "metadata.topics contains: blackwell"
},
{
"name": "cuda",
"category": "LLM 应用框架",
"description": "仓库主题标签明确指向“cuda”方向,说明这部分能力在项目定位中占比较高,阅读时值得优先关注。",
"importance": "中",
"evidence": "metadata.topics contains: cuda"
},
{
"name": "Deepseek V3",
"category": "LLM 应用框架",
"description": "仓库主题标签明确指向“Deepseek V3”方向,说明这部分能力在项目定位中占比较高,阅读时值得优先关注。",
"importance": "中",
"evidence": "metadata.topics contains: deepseek-v3"
},
{
"name": "gpt",
"category": "LLM 应用框架",
"description": "仓库主题标签明确指向“gpt”方向,说明这部分能力在项目定位中占比较高,阅读时值得优先关注。",
"importance": "中",
"evidence": "metadata.topics contains: gpt"
},
{
"name": "阅读 docs 目录",
"category": "文档体系",
"description": "docs 目录通常承载与 文档体系 相关的关键实现,适合作为进入源码细节时的优先切入点。",
"importance": "中",
"evidence": "directory_tree contains top-level entry: docs"
}
],
"suggested_learning_path": [
"先通读 README,明确项目解决的问题和核心定位",
"再结合目录结构定位入口文件、核心模块和示例代码",
"最后挑 1 到 2 个代表性模块深入阅读实现细节",
"重点关注 Prompt、检索、工具调用或 Agent 相关模块",
"建议优先阅读目录:vllm, docs, examples"
],
"relevant_directories": [
"vllm",
"docs",
"examples",
"tests",
"scripts",
"benchmarks",
"cmake",
"csrc"
],
"tags": [
"Python",
"amd",
"blackwell",
"cuda",
"deepseek",
"deepseek-v3",
"gpt",
"gpt-oss"
]
}
\ No newline at end of file
{
"repo_name": "airflow",
"repo_url": "https://github.com/apache/airflow",
"messages": [
{
"role": "system",
"content": "你是一个负责分析 GitHub 开源仓库的技术研究助手。你的任务是从 README、目录结构和仓库元信息中,提取适合后续培训、知识整理和项目分析使用的结构化知识点。输出必须严格符合给定 JSON Schema,不要输出额外解释,不要输出 Markdown。如果某个信息不能完全确定,可以基于 README 和目录结构做保守推断,但不要编造与仓库内容明显不符的信息。"
},
{
"role": "user",
"content": "请基于下面的 GitHub 仓库信息,提取结构化知识点。\n\n目标要求:\n1. 判断仓库类别,例如深度学习框架、Web 框架、LLM 应用框架、开发工具、数据平台等。\n2. 总结仓库的核心定位和学习价值。\n3. 提炼 5 到 8 个值得学习的知识点,每个知识点都要附带来源证据。\n4. 给出建议的前置知识和学习路径。\n5. 标出最值得关注的目录。\n\n仓库名称:airflow\n仓库链接:https://github.com/apache/airflow\n主要语言:Python\nStars:46099\n最近更新时间:2026-07-13T08:02:43Z\nmain_features:[\"Project Focus\", \"Principles\", \"Installing from PyPI\", \"Official source code\", \"Convenience packages\", \"User Interface\", \"Semantic versioning\", \"Version Life Cycle\"]\nmetadata:{\"owner\": \"apache\", \"default_branch\": \"main\", \"topics\": [\"airflow\", \"apache\", \"apache-airflow\", \"automation\", \"dag\", \"data-engineering\", \"data-integration\", \"data-orchestrator\", \"data-pipelines\", \"data-science\", \"elt\", \"etl\", \"machine-learning\", \"mlops\", \"orchestration\", \"python\", \"scheduler\", \"workflow\", \"workflow-engine\", \"workflow-orchestration\"]}\n\n目录结构摘录:\n├── .agents\n│ └── skills\n│ ├── aip-user-stories\n│ │ ├── references\n│ │ │ └── playbook-template.md\n│ │ └── SKILL.md\n│ ├── airflow-java-sdk\n│ │ └── SKILL.md\n│ ├── airflow-new-sdk\n│ │ └── SKILL.md\n│ ├── airflow-translations\n│ │ ├── locales\n│ │ │ ├── ar.md\n│ │ │ ├── ca.md\n│ │ │ ├── de.md\n│ │ │ ├── el.md\n│ │ │ ├── es.md\n│ │ │ ├── fr.md\n│ │ │ ├── he.md\n│ │ │ ├── hi.md\n│ │ │ ├── hu.md\n│ │ │ ├── it.md\n│ │ │ ├── ja.md\n│ │ │ ├── ko.md\n│ │ │ ├── nl.md\n│ │ │ ├── pl.md\n│ │ │ ├── pt.md\n│ │ │ ├── th.md\n│ │ │ ├── tr.md\n│ │ │ ├── zh-CN.md\n│ │ │ └── zh-TW.md\n│ │ └── SKILL.md\n│ ├── magpie-setup\n│ │ ├── adopt.md\n│ │ ├── agents.md\n│ │ ├── overrides.md\n│ │ ├── skill-sources.md\n│ │ ├── SKILL.md\n│ │ ├── unadopt.md\n│ │ ├── upgrade.md\n│ │ ├── verify.md\n│ │ └── worktree-init.md\n│ ├── prepare-providers-documentation\n│ │ └── SKILL.md\n│ └── upgrade-fab-provider\n│ └── SKILL.md\n├── .apache-magpie-overrides\n│ ├── pr-management-config.md\n│ ├── pr-management-triage-ci-check-map.md\n│ ├── pr-management-triage-comment-templates.md\n│ ├── README.md\n│ └── setup-isolated-setup-install.md\n├── .claude\n│ └── skills\n│ ├── aip-user-stories\n│ ├── airflow-translations\n│ ├── magpie-setup\n│ ├── prepare-providers-documentation\n│ └── upgrade-fab-provider\n├── .devcontainer\n│ ├── mysql\n│ │ └── devcontainer.json\n│ ├── postgres\n│ │ └── devcontainer.json\n│ └── devcontainer.json\n├── .github\n│ ├── actions\n│ │ ├── breeze\n│ │ │ └── action.yml\n│ │ ├── install-prek\n│ │ │ └── action.yml\n│ │ ├── migration_tests\n│ │ │ └── action.yml\n│ │ ├── post_tests_failure\n│ │ │ └── action.yml\n│ │ ├── post_tests_success\n│ │ │ └── action.yml\n│ │ ├── prepare_all_ci_images\n│ │ │ └── action.yml\n│ │ ├── prepare_breeze_and_image\n│ │ │ └── action.yml\n│ │ └── prepare_single_ci_image\n│ │ └── action.yml\n│ ├── instructions\n│ │ └── code-review.instructions.md\n│ ├── ISSUE_TEMPLATE\n│ │ ├── 1-airflow_bug_report.yml\n│ │ ├── 2-feature_request.yml\n│ │ ├── 3-free_form.yml\n│ │ ├── airflow_ctl_issue_template.yml\n│ │ └── config.yml\n│ ├── skills\n│ │ ├── aip-user-stories\n│ │ ├── airflow-translations\n│ │ ├── magpie-setup\n│ │ ├── prepare-providers-documentation\n│ │ └── upgrade-fab-provider\n│ ├── workflows\n│ │ ├── additional-ci-image-checks.yml\n│ │ ├── additional-prod-image-tests.yml\n│ │ ├── airflow-distributions-tests.yml\n│ │ ├── airflow-e2e-tests.yml\n│ │ ├── asf-allowlist-check.yml\n│ │ ├── automatic-backport.yml\n│ │ ├── backport-cli.yml\n│ │ ├── basic-tests.yml\n│ │ ├── check-newsfragment-pr-number.yml\n│ │ ├── ci-amd.yml\n│ │ ├── ci-arm.yml\n│ │ ├── ci-duration-monitor.yml\n│ │ ├── ci-image-build.yml\n│ │ ├── ci-image-checks.yml\n│ │ ├── ci-notification.yml\n│ │ ├── codeql-analysis.yml\n│ │ ├── e2e-flaky-tests-report.yml\n│ │ ├── finalize-tests.yml\n│ │ ├── generate-constraints.yml\n│ │ ├── helm-tests.yml\n│ │ ├── integration-system-tests.yml\n│ │ ├── java-sdk-release-verify.yml\n\nREADME 摘录:\n<!--\n Licensed to the Apache Software Foundation (ASF) under one\n or more contributor license agreements. See the NOTICE file\n distributed with this work for additional information\n regarding copyright ownership. The ASF licenses this file\n to you under the Apache License, Version 2.0 (the\n \"License\"); you may not use this file except in compliance\n with the License. You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing,\n software distributed under the License is distributed on an\n \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n KIND, either express or implied. See the License for the\n specific language governing permissions and limitations\n under the License.\n-->\n\n<!-- START Apache Airflow, please keep comment here to allow auto update of PyPI readme.md -->\n# Apache Airflow\n\n| Category | Badges |\n|------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| License | [](https://www.apache.org/licenses/LICENSE-2.0.txt) |\n| PyPI | [](https://badge.fury.io/py/apache-airflow) [](https://pypi.org/project/apache-airflow/) [](https://pypi.org/project/apache-airflow/) |\n| Containers | [](https://hub.docker.com/r/apache/airflow) [](https://hub.docker.com/r/apache/airflow) [](https://artifacthub.io/packages/search?repo=apache-airflow) |\n| Community | [](https://github.com/apache/airflow/graphs/contributors) [](https://s.apache.org/airflow-slack) [](https://insights.linuxfoundation.org/project/apache-airflow) |\n| Dev tools | [](https://github.com/j178/prek) |\n\n| Version | Build Status |\n|---------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| Main | [](https://github.com/apache/airflow/actions/workflows/ci-amd.yml) [](https://github.com/apache/airflow/actions/workflows/ci-arm.yml) |\n| 3.x | [](https://github.com/apache/airflow/actions/workflows/ci-amd.yml) [](https://github.com/apache/airflow/actions/workflows/ci-arm.yml) |\n\n<picture width=\"500\">\n \n</picture>\n\n[Apache Airflow](https://airflow.apache.org/docs/apache-airflow/stable/) (or simply Airflow) is a platform to programmatically author, schedule, and monitor workflows.\n\nWhen workflows are defined as code, they become more maintainable, versionable, testable, and collaborative.\n\nUse Airflow to author workflows (Dags) that orchestrate tasks. The Airflow scheduler executes your tasks on an array of workers while following the specified dependencies. Rich command line utilities make performing complex surgeries on Dags a snap. The rich user interface makes it easy to visualize pipelines running in production, monitor progress, and troubleshoot issues when needed.\n\n<!-- END Apache Airflow, please keep comment here to allow auto update of PyPI readme.md -->\n<!-- START doctoc generated TOC please keep comment here to allow auto update -->\n<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->\n**Table of contents**\n\n- [Project Focus](#project-focus)\n- [Principles](#principles)\n- [Requirements](#requirements)\n- [Getting started](#getting-started)\n- [Installing from PyPI](#installing-from-pypi)\n- [Installation](#installation)\n- [Official source code](#official-source-code)\n- [Convenience packages](#convenience-packages)\n- [User Interface](#user-interface)\n- [Semantic versioning](#semantic-versioning)\n- [Version Life Cycle](#version-life-cycle)\n- [Support for Python and Kubernetes versions](#support-for-python-and-kubernetes-versions)\n- [Base OS support for reference Airflow images](#base-os-support-for-reference-airflow-images)\n- [Approach to dependencies of Airflow](#approach-to-dependencies-of-airflow)\n- [Contributing](#contributing)\n- [Community standards](#community-standards)\n- [Agent-assisted contribution (apache-magpie)](#agent-assisted-contribution-apache-magpie)\n- [Voting Policy](#voting-policy)\n- [Who uses Apache Airflow?](#who-uses-apache-airflow)\n- [Who maintains Apache Airflow?](#who-maintains-apache-airflow)\n- [What goes into the next release?](#what-goes-into-the-next-release)\n- [Can I use the Apache Airflow logo in my presentation?](#can-i-use-the-apache-airflow-logo-in-my-presentation)\n- [Links](#links)\n- [Sponsors](#sponsors)\n\n<!-- END doctoc generated TOC please keep comment here to allow auto update -->\n\n## Project Focus\n\nAirflow works best with workflows that are mostly static and slowly changing. When the Dag structure is similar from one run to the next, it clarifies the unit of work and continuity. Other similar projects include [Luigi](https://github.com/spotify/luigi), [Oozie](https://oozie.apache.org/) and [Azkaban](https://azkaban.github.io/).\n\nAirflow is commonly used to process data, but has the opinion that tasks should ideally be idempotent (i.e., results of the task will be the same, and will not create duplicated data in a destination system), and should not pass large quantities of data from one task to the next (though tasks can pass metadata using Airflow's [XCom feature](https://airflow.apache.org/docs/apache-airflow/stable/concepts/xcoms.html)). For high-volume, data-intensive tasks, a best practice is to delegate to external services specializing in that type of work.\n\nAirflow is not a streaming solution, but it is often used to process real-time data, pulling data off streams in batches.\n\n## Principles\n\n- **Dynamic**: Pipelines are defined in code, enabling dynamic dag generation and parameterization.\n- **Extensible**: The Airflow framework includes a wide range of built-in operators and can be extended to fit your needs.\n- **Flexible**: Airflow leverages the [**Jinja**](https://jinja.palletsprojects.com) templating engine, allowing rich customizations.\n\n<!-- START Requirements, please keep comment here to allow auto update of PyPI readme.md -->\n## Requirements\n\nApache Airflow is tested with:\n\n| | Main version (dev) | Stable version (3.3.0) | Deprecate version (2.11.2) |\n|------------|------------------------------------|-------------------------------------|------------------------------|\n| Python | 3.10, 3.11, 3.12, 3.13, 3.14 | 3.10, 3.11, 3.12, 3.13, 3.14 | 3.10, 3.11, 3.12 |\n| Platform | AMD64/ARM64 | AMD64/ARM64 | AMD64/ARM64(\\*) |\n| Kubernetes | 1.30, 1.31, 1.32, 1.33, 1.34, 1.35 | 1.30, 1.31, 1.32, 1.33, 1.34, 1.35 | 1.26, 1.27, 1.28, 1.29, 1.30 |\n| PostgreSQL | 14, 15, 16, 17, 18 | 14, 15, 16, 17, 18 | 12, 13, 14, 15, 16 |\n| MySQL | 8.0, 8.4, Innovation | 8.0, 8.4, Innovation | 8.0, Innovation |\n| SQLite | 3.15.0+ | 3.15.0+ | 3.15.0+ |\n\n\\* Experimental\n\n**Note**: MariaDB is not tested/recommended.\n\n**Note**: SQLite is used in Airflow tests. Do not use it in production. We recommend\nusing the latest stable version of SQLite for local development.\n\n**Note**: Airflow currently can be run on POSIX-compliant Operating Systems. For development, it is regularly\ntested on fairly modern Linux Distros and recent versions of macOS.\nOn Windows you can run it via WSL2 (Windows Subsystem for Linux 2) or via Linux Containers.\nThe work to add Windows support is tracked via [#10388](https://github.com/apache/airflow/issues/10388), but\nit is not a high priority. You should only use Linux-based distros as \"Production\" execution environment\nas this is the only environment that is supported. The only distro that is used in our CI tests and that\nis used in the [Community managed DockerHub image](https://hub.docker.com/p/apache/airflow) is\n`Debian Bookworm`.\n\n<!-- END Requirements, please keep comment here to allow auto update of PyPI readme.md -->\n<!-- START Getting started, please keep comment here to allow auto update of PyPI readme.md -->\n## Getting started\n\nVisit the official Airflow website documentation (latest **stable** release) for help with\n[installing Airflow](https://airflow.apache.org/docs/apache-airflow/stable/installation/),\n[getting started](https://airflow.apache.org/docs/apache-airflow/stable/start.html), or walking\nthrough a more complete [tutorial](https://airflow.apache.org/docs/apache-airflow/stable/tutorial/).\n\n> Note: If you're looking for documentation for the main branch (latest development branch): you can find it on [s.apache.org/airflow-docs](https://s.apache.org/airflow-docs/).\n\nFor more information on Airflow Improvement Proposals (AIPs), visit\nthe [Airflow Wiki](https://cwiki.apache.org/confluence/display/AIRFLOW/Airflow+Improvement+Proposals).\n\nDocumentation for dependent projects like provider distributions, Docker image, Helm Chart, you'll find it in [the documentation index](https://airflow.apache.org/docs/).\n\n<!-- END Getting started, please keep comment here to allow auto update of PyPI readme.md -->\n<!-- START Installing from PyPI, please keep comment here to allow auto update of PyPI readme.md -->\n\n## Installing from PyPI\n\nWe publish Apache Airflow as `apache-airflow` package in PyPI. Installing it however might be sometimes tricky\nbecause Airflow is a bit of both a library and application. Libraries usually keep their dependencies open, and\napplications usually pin them, but we should do neither and both simultaneously. We decided to keep\nour dependencies as open as possible (in `pyproject.toml`) so users can install different versions of libraries\nif needed. This means that `pip install apache-airflow` will not work from time to time or will\nproduce unusable Airflow installation.\n\nTo have repeatable installation, however, we keep a set of \"known-to-be-working\" constrain\n"
}
],
"json_schema": {
"title": "repo_knowledge_extraction",
"type": "object",
"additionalProperties": false,
"required": [
"repo_name",
"repo_url",
"repo_category",
"summary",
"learning_value",
"prerequisites",
"knowledge_points",
"suggested_learning_path",
"relevant_directories",
"tags"
],
"properties": {
"repo_name": {
"type": "string"
},
"repo_url": {
"type": "string"
},
"repo_category": {
"type": "string"
},
"summary": {
"type": "string"
},
"learning_value": {
"type": "string"
},
"prerequisites": {
"type": "array",
"items": {
"type": "string"
}
},
"knowledge_points": {
"type": "array",
"items": {
"type": "object",
"additionalProperties": false,
"required": [
"name",
"category",
"description",
"importance",
"evidence"
],
"properties": {
"name": {
"type": "string"
},
"category": {
"type": "string"
},
"description": {
"type": "string"
},
"importance": {
"type": "string"
},
"evidence": {
"type": "string"
}
}
}
},
"suggested_learning_path": {
"type": "array",
"items": {
"type": "string"
}
},
"relevant_directories": {
"type": "array",
"items": {
"type": "string"
}
},
"tags": {
"type": "array",
"items": {
"type": "string"
}
}
}
}
}
\ No newline at end of file
{
"repo_name": "fastapi",
"repo_url": "https://github.com/fastapi/fastapi",
"messages": [
{
"role": "system",
"content": "你是一个负责分析 GitHub 开源仓库的技术研究助手。你的任务是从 README、目录结构和仓库元信息中,提取适合后续培训、知识整理和项目分析使用的结构化知识点。输出必须严格符合给定 JSON Schema,不要输出额外解释,不要输出 Markdown。如果某个信息不能完全确定,可以基于 README 和目录结构做保守推断,但不要编造与仓库内容明显不符的信息。"
},
{
"role": "user",
"content": "请基于下面的 GitHub 仓库信息,提取结构化知识点。\n\n目标要求:\n1. 判断仓库类别,例如深度学习框架、Web 框架、LLM 应用框架、开发工具、数据平台等。\n2. 总结仓库的核心定位和学习价值。\n3. 提炼 5 到 8 个值得学习的知识点,每个知识点都要附带来源证据。\n4. 给出建议的前置知识和学习路径。\n5. 标出最值得关注的目录。\n\n仓库名称:fastapi\n仓库链接:https://github.com/fastapi/fastapi\n主要语言:Python\nStars:100418\n最近更新时间:2026-07-13T08:08:30Z\nmain_features:[\"Fast: Very high performance, on par with NodeJS and Go (thanks to Starlette and Pydantic). One of the fastest Python frameworks available\", \"Fast to code: Increase the speed to develop features by about 200% to 300%\", \"Fewer bugs: Reduce about 40% of human (developer) induced errors\", \"Intuitive: Great editor support. Completion everywhere. Less time debugging\", \"Easy: Designed to be easy to use and learn. Less time reading docs\", \"Short: Minimize code duplication. Multiple features from each parameter declaration. Fewer bugs\", \"Robust: Get production-ready code. With automatic interactive documentation\", \"Standards-based: Based on (and fully compatible with) the open standards for APIs: OpenAPI (previously known as Swagger) and JSON Schema\"]\nmetadata:{\"owner\": \"fastapi\", \"default_branch\": \"master\", \"topics\": [\"api\", \"async\", \"asyncio\", \"fastapi\", \"framework\", \"json\", \"json-schema\", \"openapi\", \"openapi3\", \"pydantic\", \"python\", \"python-types\", \"python3\", \"redoc\", \"rest\", \"starlette\", \"swagger\", \"swagger-ui\", \"uvicorn\", \"web\"]}\n\n目录结构摘录:\n├── .github\n│ ├── DISCUSSION_TEMPLATE\n│ │ ├── questions.yml\n│ │ └── translations.yml\n│ ├── ISSUE_TEMPLATE\n│ │ ├── config.yml\n│ │ └── privileged.yml\n│ ├── workflows\n│ │ ├── add-to-project.yml\n│ │ ├── build-docs.yml\n│ │ ├── bump-pre-commit-hooks.yml\n│ │ ├── contributors.yml\n│ │ ├── create-draft-release.yml\n│ │ ├── deploy-docs.yml\n│ │ ├── detect-conflicts.yml\n│ │ ├── guard-dependencies.yml\n│ │ ├── issue-manager.yml\n│ │ ├── label-approved.yml\n│ │ ├── labeler.yml\n│ │ ├── latest-changes.yml\n│ │ ├── notify-translations.yml\n│ │ ├── people.yml\n│ │ ├── pre-commit.yml\n│ │ ├── prepare-release.yml\n│ │ ├── publish.yml\n│ │ ├── smokeshow.yml\n│ │ ├── sponsors.yml\n│ │ ├── test-redistribute.yml\n│ │ ├── test.yml\n│ │ ├── topic-repos.yml\n│ │ ├── translate.yml\n│ │ └── zizmor.yml\n│ ├── dependabot.yml\n│ └── labeler.yml\n├── docs\n│ ├── de\n│ │ ├── docs\n│ │ │ ├── about\n│ │ │ │ └── index.md\n│ │ │ ├── advanced\n│ │ │ │ ├── security\n│ │ │ │ │ ├── http-basic-auth.md\n│ │ │ │ │ ├── index.md\n│ │ │ │ │ └── oauth2-scopes.md\n│ │ │ │ ├── additional-responses.md\n│ │ │ │ ├── additional-status-codes.md\n│ │ │ │ ├── advanced-dependencies.md\n│ │ │ │ ├── advanced-python-types.md\n│ │ │ │ ├── async-tests.md\n│ │ │ │ ├── behind-a-proxy.md\n│ │ │ │ ├── custom-response.md\n│ │ │ │ ├── dataclasses.md\n│ │ │ │ ├── events.md\n│ │ │ │ ├── generate-clients.md\n│ │ │ │ ├── index.md\n│ │ │ │ ├── json-base64-bytes.md\n│ │ │ │ ├── middleware.md\n│ │ │ │ ├── openapi-callbacks.md\n│ │ │ │ ├── openapi-webhooks.md\n│ │ │ │ ├── path-operation-advanced-configuration.md\n│ │ │ │ ├── response-change-status-code.md\n│ │ │ │ ├── response-cookies.md\n│ │ │ │ ├── response-directly.md\n│ │ │ │ ├── response-headers.md\n│ │ │ │ ├── settings.md\n│ │ │ │ ├── stream-data.md\n│ │ │ │ ├── strict-content-type.md\n│ │ │ │ ├── sub-applications.md\n│ │ │ │ ├── templates.md\n│ │ │ │ ├── testing-dependencies.md\n│ │ │ │ ├── testing-events.md\n│ │ │ │ ├── testing-websockets.md\n│ │ │ │ ├── using-request-directly.md\n│ │ │ │ ├── websockets.md\n│ │ │ │ └── wsgi.md\n│ │ │ ├── deployment\n│ │ │ │ ├── cloud.md\n│ │ │ │ ├── concepts.md\n│ │ │ │ ├── docker.md\n│ │ │ │ ├── fastapicloud.md\n│ │ │ │ ├── https.md\n│ │ │ │ ├── index.md\n│ │ │ │ ├── manually.md\n│ │ │ │ ├── server-workers.md\n│ │ │ │ └── versions.md\n│ │ │ ├── how-to\n│ │ │ │ ├── authentication-error-status-code.md\n│ │ │ │ ├── conditional-openapi.md\n│ │ │ │ ├── configure-swagger-ui.md\n│ │ │ │ ├── custom-docs-ui-assets.md\n│ │ │ │ ├── custom-request-and-route.md\n│ │ │ │ ├── extending-openapi.md\n│ │ │ │ ├── general.md\n│ │ │ │ ├── graphql.md\n│ │ │ │ ├── index.md\n│ │ │ │ ├── migrate-from-pydantic-v1-to-pydantic-v2.md\n│ │ │ │ ├── separate-openapi-schemas.md\n│ │ │ │ └── testing-database.md\n│ │ │ ├── learn\n│ │ │ │ └── index.md\n│ │ │ ├── resources\n│ │ │ │ └── index.md\n│ │ │ ├── tutorial\n│ │ │ │ ├── dependencies\n│ │ │ │ │ ├── classes-as-dependencies.md\n│ │ │ │ │ ├── dependencies-in-path-operation-decorators.md\n│ │ │ │ │ ├── dependencies-with-yield.md\n│ │ │ │ │ ├── global-dependencies.md\n│ │ │ │ │ ├── index.md\n│ │ │ │ │ └── sub-dependencies.md\n│ │ │ │ ├── security\n│ │ │ │ │ ├── first-steps.md\n│ │ │ │ │ ├── get-current-user.md\n│ │ │ │ │ ├── index.md\n│ │ │ │ │ ├── oauth2-jwt.md\n│ │ │ │ │ └── simple-oauth2.md\n│ │ │ │ ├── background-tasks.md\n│ │ │ │ ├── bigger-applications.md\n│ │ │ │ ├── body-fields.md\n│ │ │ │ ├── body-multiple-params.md\n\nREADME 摘录:\n<p align=\"center\">\n <a href=\"https://fastapi.tiangolo.com\"></a>\n</p>\n<p align=\"center\">\n <em>FastAPI framework, high performance, easy to learn, fast to code, ready for production</em>\n</p>\n<p align=\"center\">\n<a href=\"https://github.com/fastapi/fastapi/actions?query=workflow%3ATest+event%3Apush+branch%3Amaster\">\n \n</a>\n<a href=\"https://coverage-badge.samuelcolvin.workers.dev/redirect/fastapi/fastapi\">\n \n</a>\n<a href=\"https://pypi.org/project/fastapi\">\n \n</a>\n<a href=\"https://pypi.org/project/fastapi\">\n \n</a>\n</p>\n\n---\n\n**Documentation**: [https://fastapi.tiangolo.com](https://fastapi.tiangolo.com)\n\n**Source Code**: [https://github.com/fastapi/fastapi](https://github.com/fastapi/fastapi)\n\n---\n\nFastAPI is a modern, fast (high-performance), web framework for building APIs with Python based on standard Python type hints.\n\nThe key features are:\n\n* **Fast**: Very high performance, on par with **NodeJS** and **Go** (thanks to Starlette and Pydantic). [One of the fastest Python frameworks available](#performance).\n* **Fast to code**: Increase the speed to develop features by about 200% to 300%. *\n* **Fewer bugs**: Reduce about 40% of human (developer) induced errors. *\n* **Intuitive**: Great editor support. <dfn title=\"also known as auto-complete, autocompletion, IntelliSense\">Completion</dfn> everywhere. Less time debugging.\n* **Easy**: Designed to be easy to use and learn. Less time reading docs.\n* **Short**: Minimize code duplication. Multiple features from each parameter declaration. Fewer bugs.\n* **Robust**: Get production-ready code. With automatic interactive documentation.\n* **Standards-based**: Based on (and fully compatible with) the open standards for APIs: [OpenAPI](https://github.com/OAI/OpenAPI-Specification) (previously known as Swagger) and [JSON Schema](https://json-schema.org/).\n\n<small>* estimation based on tests conducted by an internal development team, building production applications.</small>\n\n## Sponsors\n\n<!-- sponsors -->\n### Keystone Sponsor\n\n<a href=\"https://fastapicloud.com\" target=\"_blank\" title=\"FastAPI Cloud. By the same team behind FastAPI. You code. We Cloud.\"></a>\n\n### Gold Sponsors\n\n<a href=\"https://blockbee.io?ref=fastapi\" target=\"_blank\" title=\"BlockBee Cryptocurrency Payment Gateway\"></a>\n<a href=\"https://www.propelauth.com/?utm_source=fastapi&utm_campaign=1223&utm_medium=mainbadge\" target=\"_blank\" title=\"Auth, user management and more for your B2B product\"></a>\n<a href=\"https://docs.render.com/deploy-fastapi?utm_source=deploydoc&utm_medium=referral&utm_campaign=fastapi\" target=\"_blank\" title=\"Deploy & scale any full-stack web app on Render. Focus on building apps, not infra.\"></a>\n<a href=\"https://www.coderabbit.ai/?utm_source=fastapi&utm_medium=badge&utm_campaign=fastapi\" target=\"_blank\" title=\"Cut Code Review Time & Bugs in Half with CodeRabbit\"></a>\n<a href=\"https://subtotal.com/?utm_source=fastapi&utm_medium=sponsorship&utm_campaign=open-source\" target=\"_blank\" title=\"The Gold Standard in Retail Account Linking\"></a>\n<a href=\"https://docs.railway.com/guides/fastapi?utm_medium=integration&utm_source=docs&utm_campaign=fastapi\" target=\"_blank\" title=\"Deploy enterprise applications at startup speed\"></a>\n<a href=\"https://serpapi.com/?utm_source=fastapi_website\" target=\"_blank\" title=\"SerpApi: Web Search API\"></a>\n<a href=\"https://www.greptile.com/?utm_source=fastapi&utm_medium=sponsorship&utm_campaign=fastapi_sponsor_page\" target=\"_blank\" title=\"Greptile: The AI Code Reviewer\"></a>\n\n### Silver Sponsors\n\n<a href=\"https://databento.com/?utm_source=fastapi&utm_medium=sponsor&utm_content=display\" target=\"_blank\" title=\"Pay as you go for market data\"></a>\n<a href=\"https://www.svix.com/\" target=\"_blank\" title=\"Svix - Webhooks as a service\"></a>\n<a href=\"https://www.permit.io/blog/implement-authorization-in-fastapi?utm_source=github&utm_medium=referral&utm_campaign=fastapi\" target=\"_blank\" title=\"Fine-Grained Authorization for FastAPI\"></a>\n<a href=\"https://dribia.com/en/\" target=\"_blank\" title=\"Dribia - Data Science within your reach\"></a>\n<a href=\"https://www.bairesdev.com/\" target=\"_blank\" title=\"BairesDev | Nearshore Software Development & Staff Augmentation Company\"></a>\n<a href=\"https://tutorcruncher.com/?utm_source=fastapi\" target=\"_blank\" title=\"TutorCruncher\"></a>\n\n<!-- /sponsors -->\n\n[Other sponsors](https://fastapi.tiangolo.com/fastapi-people/#sponsors)\n\n## Opinions\n\n<div class=\"only-github\" markdown=\"1\">\n\n\"_[...] I'm using **FastAPI** a ton these days. [...] I'm actually planning to use it for all of my team's **ML services at Microsoft**. Some of them are getting integrated into the core **Windows** product and some **Office** products._\"\n\n<div style=\"text-align: right; margin-right: 10%;\">Kabir Khan - <strong>Microsoft</strong> <a href=\"https://github.com/fastapi/fastapi/pull/26\"><small>(ref)</small></a></div>\n\n---\n\n\"_We adopted the **FastAPI** library to spawn a **REST** server that can be queried to obtain **predictions**. [for Ludwig]_\"\n\n<div style=\"text-align: right; margin-right: 10%;\">Piero Molino, Yaroslav Dudin, and Sai Sumanth Miryala - <strong>Uber</strong> <a href=\"https://eng.uber.com/ludwig-v0-2/\"><small>(ref)</small></a></div>\n\n---\n\n\"_**Netflix** is pleased to announce the open-source release of our **crisis management** orchestration framework: **Dispatch**! [built with **FastAPI**]_\"\n\n<div style=\"text-align: right; margin-right: 10%;\">Kevin Glisson, Marc Vilanova, Forest Monsen - <strong>Netflix</strong> <a href=\"https://netflixtechblog.com/introducing-dispatch-da4b8a2a8072\"><small>(ref)</small></a></div>\n\n---\n\n\"_If anyone is looking to build a production Python API, I would highly recommend **FastAPI**. It is **beautifully designed**, **simple to use** and **highly scalable**, it has become a **key component** in our API first development strategy and is driving many automations and services such as our Virtual TAC Engineer._\"\n\n<div style=\"text-align: right; margin-right: 10%;\">Deon Pillsbury - <strong>Cisco</strong> <a href=\"https://www.linkedin.com/posts/deonpillsbury_cisco-cx-python-activity-6963242628536487936-trAp/\"><small>(ref)</small></a></div>\n\n---\n\n</div>\n\n## FastAPI Conf\n\n[**FastAPI Conf '26**](https://fastapiconf.com) is happening on **October 28, 2026** in **Amsterdam, NL**. All about FastAPI, right from the source. 🎤\n\n<a class=\"fastapi-feature-banner\" href=\"https://fastapiconf.com\"></a>\n\n## FastAPI mini documentary\n\nThere's a [FastAPI mini documentary](https://www.youtube.com/watch?v=mpR8ngthqiE) released at the end of 2025, you can watch it online:\n\n<a class=\"fastapi-feature-banner\" href=\"https://www.youtube.com/watch?v=mpR8ngthqiE\"></a>\n\n## **Typer**, the FastAPI of CLIs\n\n<a href=\"https://typer.tiangolo.com\"></a>\n\nIf you are building a <abbr title=\"Command Line Interface\">CLI</abbr> app to be used in the terminal instead of a web API, check out [**Typer**](https://typer.tiangolo.com/).\n\n**Typer** is FastAPI's little sibling. And it's intended to be the **FastAPI of CLIs**. ⌨️ 🚀\n\n## Requirements\n\nFastAPI stands on the shoulders of giants:\n\n* [Starlette](https://www.starlette.dev/) for the web parts.\n* [Pydantic](https://docs.pydantic.dev/) for the data parts.\n\n## Installation\n\nCreate and activate a [virtual environment](https://fastapi.tiangolo.com/virtual-environments/) and then install FastAPI:\n\n<div class=\"termy\">\n\n</div>\n\n**Note**: Make sure you put `\"fastapi[standard]\"` in quotes to ensure it works in all terminals.\n\n## Example\n\n### Create it\n\nCreate a file `main.py` with:\n\n<details markdown=\"1\">\n<summary>Or use <code>async def</code>...</summary>\n\nIf your code uses `async` / `await`, use `async def`:\n\n**Note**:\n\nIf you don't know, check the _\"In a hurry?\"_ section about [`async` and `await` in the docs](https://fastapi.tiangolo.com/async/#in-a-hurry).\n\n</details>\n\n### Run it\n\nRun the server with:\n\n<div class=\"termy\">\n\n</div>\n\n<details markdown=\"1\">\n<summary>About the command <code>fastapi dev</code>...</summary>\n\nThe command `fastapi dev` reads your `main.py` file automatically, detects the **FastAPI** app in it, and starts a server using [Uvicorn](https://www.uvicorn.dev).\n\nBy default, `fastapi dev` will start with auto-reload enabled for local development.\n\nYou can read more about it in the [FastAPI CLI docs](https://fastapi.tiangolo.com/fastapi-cli/).\n\n</details>\n\n### Check it\n\nOpen your browser at [http://127.0.0.1:8000/items/5?q=somequery](http://127.0.0.1:8000/items/5?q=somequery).\n\nYou will see the JSON response as:\n\nYou already created an API that:\n\n* Receives HTTP requests in the _paths_ `/` and `/items/{item_id}`.\n* Both _paths_ take `GET` <em>operations</em> (also known as HTTP _methods_).\n* The _path_ `/items/{item_id}` has a _path parameter_ `item_id` that should be an `int`.\n* The _path_ `/items/{item_id}` has an optional `str` _query parameter_ `q`.\n\n### Interactive API docs\n\nNow go to [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).\n\nYou will see the automatic interactive API documentation (provided by [Swagger UI](https://github.com/swagger-api/swagger-ui)):\n\n### Alternative API docs\n\nAnd now, go to [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc).\n\nYou will see the alternative automatic documentation (provided by [ReDoc](https://github.com/Rebilly/ReDoc)):\n\n## Example upgrade\n\nNow modify the file `main.py` to receive a body from a `PUT` request.\n\nDeclare the body using standard Python types, thanks to Pydantic.\n\nThe `fastapi dev` server should reload automatically.\n\n### Interactive API docs upgrade\n\nNow go to [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).\n\n* The interactive API documentation will be automatically updated, including the new body:\n\n* Click on the button \"Try it out\", it allows you to fill the parameters and directly interact with the API:\n\n* Then click on the \"Execute\" button, the user interface will communicate with your API, send the parameters, get the results and show them on the screen:\n\n### Alternative API docs upgrade\n\nAnd now, go to [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc).\n\n* The alternative documentation will also reflect the new query parameter and body:\n\n### Recap\n\nIn summary, you declare **once** the types of parameters, body, etc. as function parameters.\n\nYou do that with standard modern Python types.\n\nYou don't have to learn a new syntax, the methods or classes of a specific library, etc.\n\nJust standard **Python**.\n\nFor example, for an `int`:\n\nor for a more complex `Item` model:\n\n...and with that single declaration you get:\n\n* Editor support, including:\n * Completion.\n * Type checks.\n* Validation of data:\n * Automatic and clear errors when the data is invalid.\n * Validation even for deeply nested JSON objects.\n* <dfn title=\"also known as: serialization, parsing, marshalling\">Conversion</dfn> of input data: coming from the network to Python data and types. Reading from:\n * JSON.\n * Path parameters.\n * Query parameters.\n * Cookies.\n * Headers.\n * Forms.\n * Files.\n* <dfn title=\"also known as: serialization, parsing, marshalling\">Conversion</dfn> of output data: converting from Python data and types to network data (as JSON):\n * Convert Python types (`str`, `int`, `float`, `bool`, `list`, etc).\n * `datetime` objects.\n * `UUID` objects.\n * Database models.\n * ...and many more.\n* Automatic interactive API documentation, including 2 alternative user interfaces:\n * Swagger UI.\n * ReDoc.\n\n---\n\nComing back to the previous code example, **FastAPI** will:\n\n* Validate that there is an `item_id` in the path for `GET` and `PUT` requests.\n* Validate that the `item_id` is of type `int` for `GET` and `PUT` requests.\n * If it is not, the client will see a useful, clear error.\n* Check if there is an optional query parameter named `q` (as in `http://127.0.0.1:8000/items/foo?q=somequery`) for `GET` requests.\n * As the `q` parameter is declared with `= None`, it is optional.\n * Without the `None` it would be required (as is the body in the case wi\n"
}
],
"json_schema": {
"title": "repo_knowledge_extraction",
"type": "object",
"additionalProperties": false,
"required": [
"repo_name",
"repo_url",
"repo_category",
"summary",
"learning_value",
"prerequisites",
"knowledge_points",
"suggested_learning_path",
"relevant_directories",
"tags"
],
"properties": {
"repo_name": {
"type": "string"
},
"repo_url": {
"type": "string"
},
"repo_category": {
"type": "string"
},
"summary": {
"type": "string"
},
"learning_value": {
"type": "string"
},
"prerequisites": {
"type": "array",
"items": {
"type": "string"
}
},
"knowledge_points": {
"type": "array",
"items": {
"type": "object",
"additionalProperties": false,
"required": [
"name",
"category",
"description",
"importance",
"evidence"
],
"properties": {
"name": {
"type": "string"
},
"category": {
"type": "string"
},
"description": {
"type": "string"
},
"importance": {
"type": "string"
},
"evidence": {
"type": "string"
}
}
}
},
"suggested_learning_path": {
"type": "array",
"items": {
"type": "string"
}
},
"relevant_directories": {
"type": "array",
"items": {
"type": "string"
}
},
"tags": {
"type": "array",
"items": {
"type": "string"
}
}
}
}
}
\ No newline at end of file
{
"repo_name": "transformers",
"repo_url": "https://github.com/huggingface/transformers",
"messages": [
{
"role": "system",
"content": "你是一个负责分析 GitHub 开源仓库的技术研究助手。你的任务是从 README、目录结构和仓库元信息中,提取适合后续培训、知识整理和项目分析使用的结构化知识点。输出必须严格符合给定 JSON Schema,不要输出额外解释,不要输出 Markdown。如果某个信息不能完全确定,可以基于 README 和目录结构做保守推断,但不要编造与仓库内容明显不符的信息。"
},
{
"role": "user",
"content": "请基于下面的 GitHub 仓库信息,提取结构化知识点。\n\n目标要求:\n1. 判断仓库类别,例如深度学习框架、Web 框架、LLM 应用框架、开发工具、数据平台等。\n2. 总结仓库的核心定位和学习价值。\n3. 提炼 5 到 8 个值得学习的知识点,每个知识点都要附带来源证据。\n4. 给出建议的前置知识和学习路径。\n5. 标出最值得关注的目录。\n\n仓库名称:transformers\n仓库链接:https://github.com/huggingface/transformers\n主要语言:Python\nStars:162559\n最近更新时间:2026-07-13T07:42:55Z\nmain_features:[\"Why should I use Transformers?\", \"When shouldn't I use Transformers?\", \"projects using Transformers\", \"Example models\", \"Citation\"]\nmetadata:{\"owner\": \"huggingface\", \"default_branch\": \"main\", \"topics\": [\"audio\", \"deep-learning\", \"deepseek\", \"gemma\", \"glm\", \"hacktoberfest\", \"llm\", \"machine-learning\", \"model-hub\", \"natural-language-processing\", \"nlp\", \"pretrained-models\", \"python\", \"pytorch\", \"pytorch-transformers\", \"qwen\", \"speech-recognition\", \"transformer\", \"vlm\"]}\n\n目录结构摘录:\n├── .ai\n│ ├── skills\n│ │ └── add-or-fix-type-checking\n│ │ └── SKILL.md\n│ └── AGENTS.md\n├── .circleci\n│ ├── config.yml\n│ ├── config.yml.bak\n│ ├── create_circleci_config.py\n│ ├── parse_test_outputs.py\n│ └── TROUBLESHOOT.md\n├── .github\n│ ├── conda\n│ │ ├── build.sh\n│ │ └── meta.yaml\n│ ├── ISSUE_TEMPLATE\n│ │ ├── bug-report.yml\n│ │ ├── config.yml\n│ │ ├── feature-request.yml\n│ │ ├── i18n.md\n│ │ ├── migration.yml\n│ │ └── new-model-addition.yml\n│ ├── scripts\n│ │ ├── assign_reviewers.py\n│ │ └── codeowners_for_review_action\n│ ├── workflows\n│ │ ├── add-model-like.yml\n│ │ ├── anti-slop.yml\n│ │ ├── assign-reviewers.yml\n│ │ ├── benchmark.yml\n│ │ ├── benchmark_v2.yml\n│ │ ├── benchmark_v2_a10_caller.yml\n│ │ ├── benchmark_v2_mi300_caller.yml\n│ │ ├── build-ci-docker-images.yml\n│ │ ├── build-docker-images.yml\n│ │ ├── build-nightly-ci-docker-images.yml\n│ │ ├── build-past-ci-docker-images.yml\n│ │ ├── build_documentation.yml\n│ │ ├── build_pr_documentation.yml\n│ │ ├── check-workflow-permissions.yml\n│ │ ├── check_failed_tests.yml\n│ │ ├── check_tiny_models.yml\n│ │ ├── circleci-failure-summary-comment.yml.bak\n│ │ ├── codeql.yml\n│ │ ├── collated-reports.yml\n│ │ ├── dependents-smoke-test.yml\n│ │ ├── doctest_job.yml\n│ │ ├── doctests.yml\n│ │ ├── extras-smoke-test.yml\n│ │ ├── get-pr-info.yml\n│ │ ├── get-pr-number.yml\n│ │ ├── model_jobs.yml\n│ │ ├── model_jobs_intel_gaudi.yml\n│ │ ├── new_model_pr_merged_notification.yml\n│ │ ├── nightly-integration-failure-triage-caller.yml\n│ │ ├── pr-ci-caller.yml\n│ │ ├── pr-ci-post-dashboard-link.yml\n│ │ ├── pr-ci-security-gate.yml\n│ │ ├── pr-repo-consistency-bot.yml\n│ │ ├── pr_build_doc_with_comment.yml\n│ │ ├── pr_slow_ci_suggestion.yml\n│ │ ├── push-important-models.yml\n│ │ ├── release-conda.yml\n│ │ ├── release.yml\n│ │ ├── self-comment-ci.yml\n│ │ ├── self-nightly-caller.yml\n│ │ ├── self-nightly-past-ci-caller.yml\n│ │ ├── self-past-caller.yml\n│ │ ├── self-scheduled-amd-caller.yml\n│ │ ├── self-scheduled-amd-mi250-caller.yml\n│ │ ├── self-scheduled-amd-mi300-caller.yml\n│ │ ├── self-scheduled-amd-mi355-caller.yml\n│ │ ├── self-scheduled-caller.yml\n│ │ ├── self-scheduled-flash-attn-caller.yml\n│ │ ├── self-scheduled-intel-gaudi.yml\n│ │ ├── self-scheduled-intel-gaudi3-caller.yml\n│ │ ├── self-scheduled.yml\n│ │ ├── slack-report.yml\n│ │ ├── ssh-runner.yml\n│ │ ├── stale.yml\n│ │ ├── trl-ci-bot.yml\n│ │ ├── TROUBLESHOOT.md\n│ │ ├── trufflehog.yml\n│ │ ├── update_metdata.yml\n│ │ └── upload_pr_documentation.yml\n│ ├── copilot-instructions.md\n│ ├── dependabot.yml\n│ └── PULL_REQUEST_TEMPLATE.md\n├── benchmark\n│ ├── benches\n│ │ └── llama.py\n│ ├── config\n│ │ └── generation.yaml\n│ ├── utils\n│ │ └── init_db.sql\n│ ├── .gitignore\n│ ├── __init__.py\n│ ├── benchmark.py\n│ ├── benchmarks_entrypoint.py\n│ ├── default.yml\n│ ├── grafana_dashboard.json\n│ ├── grafana_datasource.yaml\n│ ├── optimum_benchmark_wrapper.py\n│ ├── README.md\n│ └── requirements.txt\n├── benchmark_v2\n│ ├── benchmark_scripts\n│ │ └── continuous_batching_overall.py\n│ ├── framework\n│ │ ├── benchmark_config.py\n│ │ ├── benchmark_runner.py\n│ │ ├── data_classes.py\n│ │ └── hardware_metrics.py\n│ ├── .gitignore\n│ ├── README.md\n│ ├── requirements.txt\n│ └── run_benchmarks.py\n├── docker\n│ ├── transformers-all-latest-gpu\n│ │ └── Dockerfile\n\nREADME 摘录:\n<!---\nCopyright 2020 The HuggingFace Team. All rights reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n-->\n\n<p align=\"center\">\n \n <br/>\n <br/>\n</p>\n\n<p align=\"center\">\n <a href=\"https://huggingface.com/models\"></a>\n <a href=\"https://circleci.com/gh/huggingface/transformers\"></a>\n <a href=\"https://github.com/huggingface/transformers/blob/main/LICENSE\"></a>\n <a href=\"https://huggingface.co/docs/transformers/index\"></a>\n <a href=\"https://github.com/huggingface/transformers/releases\"></a>\n <a href=\"https://github.com/huggingface/transformers/blob/main/CODE_OF_CONDUCT.md\"></a>\n <a href=\"https://zenodo.org/badge/latestdoi/155220641\"></a>\n</p>\n\n<h4 align=\"center\">\n <p>\n <b>English</b> |\n <a href=\"https://github.com/huggingface/transformers/blob/main/i18n/README_zh-hans.md\">简体中文</a> |\n <a href=\"https://github.com/huggingface/transformers/blob/main/i18n/README_zh-hant.md\">繁體中文</a> |\n <a href=\"https://github.com/huggingface/transformers/blob/main/i18n/README_ko.md\">한국어</a> |\n <a href=\"https://github.com/huggingface/transformers/blob/main/i18n/README_es.md\">Español</a> |\n <a href=\"https://github.com/huggingface/transformers/blob/main/i18n/README_ja.md\">日本語</a> |\n <a href=\"https://github.com/huggingface/transformers/blob/main/i18n/README_hd.md\">हिन्दी</a> |\n <a href=\"https://github.com/huggingface/transformers/blob/main/i18n/README_ru.md\">Русский</a> |\n <a href=\"https://github.com/huggingface/transformers/blob/main/i18n/README_pt-br.md\">Português</a> |\n <a href=\"https://github.com/huggingface/transformers/blob/main/i18n/README_te.md\">తెలుగు</a> |\n <a href=\"https://github.com/huggingface/transformers/blob/main/i18n/README_fr.md\">Français</a> |\n <a href=\"https://github.com/huggingface/transformers/blob/main/i18n/README_de.md\">Deutsch</a> |\n <a href=\"https://github.com/huggingface/transformers/blob/main/i18n/README_it.md\">Italiano</a> |\n <a href=\"https://github.com/huggingface/transformers/blob/main/i18n/README_vi.md\">Tiếng Việt</a> |\n <a href=\"https://github.com/huggingface/transformers/blob/main/i18n/README_ar.md\">العربية</a> |\n <a href=\"https://github.com/huggingface/transformers/blob/main/i18n/README_ur.md\">اردو</a> |\n <a href=\"https://github.com/huggingface/transformers/blob/main/i18n/README_bn.md\">বাংলা</a> |\n <a href=\"https://github.com/huggingface/transformers/blob/main/i18n/README_fa.md\">فارسی</a> |\n <a href=\"https://github.com/huggingface/transformers/blob/main/i18n/README_tr.md\">Türkçe</a> |\n </p>\n</h4>\n\n<h3 align=\"center\">\n <p>State-of-the-art pretrained models for inference and training</p>\n</h3>\n\n<h3 align=\"center\">\n \n</h3>\n\nTransformers acts as the model-definition framework for state-of-the-art machine learning with text, computer\nvision, audio, video, and multimodal models, for both inference and training.\n\nIt centralizes the model definition so that this definition is agreed upon across the ecosystem. `transformers` is the\npivot across frameworks: if a model definition is supported, it will be compatible with the majority of training\nframeworks (Axolotl, Unsloth, DeepSpeed, FSDP, PyTorch-Lightning, ...), inference engines (vLLM, SGLang, TGI, ...),\nand adjacent modeling libraries (llama.cpp, mlx, ...) which leverage the model definition from `transformers`.\n\nWe pledge to help support new state-of-the-art models and democratize their usage by having their model definition be\nsimple, customizable, and efficient.\n\nThere are over 1M+ Transformers [model checkpoints](https://huggingface.co/models?library=transformers&sort=trending) on the [Hugging Face Hub](https://huggingface.co/models) you can use.\n\nExplore the [Hub](https://huggingface.co/) today to find a model and use Transformers to help you get started right away.\n\n## Installation\n\nTransformers works with Python 3.10+, and [PyTorch](https://pytorch.org/get-started/locally/) 2.4+.\n\nCreate and activate a virtual environment with [venv](https://docs.python.org/3/library/venv.html) or [uv](https://docs.astral.sh/uv/), a fast Rust-based Python package and project manager.\n\nInstall Transformers in your virtual environment.\n\nInstall Transformers from source if you want the latest changes in the library or are interested in contributing. However, the *latest* version may not be stable. Feel free to open an [issue](https://github.com/huggingface/transformers/issues) if you encounter an error.\n\n## Quickstart\n\nGet started with Transformers right away with the [Pipeline](https://huggingface.co/docs/transformers/pipeline_tutorial) API. The `Pipeline` is a high-level inference class that supports text, audio, vision, and multimodal tasks. It handles preprocessing the input and returns the appropriate output.\n\nInstantiate a pipeline and specify model to use for text generation. The model is downloaded and cached so you can easily reuse it again. Finally, pass some text to prompt the model.\n\nTo chat with a model, the usage pattern is the same. The only difference is you need to construct a chat history (the input to `Pipeline`) between you and the system.\n\n> [!TIP]\n> You can also chat with a model directly from the command line, as long as [`transformers serve` is running](https://huggingface.co/docs/transformers/main/en/serving).\n> \n\nExpand the examples below to see how `Pipeline` works for different modalities and tasks.\n\n<details>\n<summary>Automatic speech recognition</summary>\n\n</details>\n\n<details>\n<summary>Image classification</summary>\n\n<h3 align=\"center\">\n <a></a>\n</h3>\n\n</details>\n\n<details>\n<summary>Visual question answering</summary>\n\n<h3 align=\"center\">\n <a></a>\n</h3>\n\n</details>\n\n## Why should I use Transformers?\n\n1. Easy-to-use state-of-the-art models:\n - High performance on natural language understanding & generation, computer vision, audio, video, and multimodal tasks.\n - Low barrier to entry for researchers, engineers, and developers.\n - Few user-facing abstractions with just three classes to learn.\n - A unified API for using all our pretrained models.\n\n1. Lower compute costs, smaller carbon footprint:\n - Share trained models instead of training from scratch.\n - Reduce compute time and production costs.\n - Hundreds of model architectures with 1M+ pretrained checkpoints across all modalities.\n\n1. Choose the right framework for every part of a model's lifetime:\n - Train state-of-the-art models in 3 lines of code.\n - Move a single model between PyTorch/JAX/TF2.0 frameworks at will.\n - Pick the right framework for training, evaluation, and production.\n\n1. Easily customize a model or an example to your needs:\n - We provide examples for each architecture to reproduce the results published by its original authors.\n - Model internals are exposed as consistently as possible.\n - Model files can be used independently of the library for quick experiments.\n\n<a target=\"_blank\" href=\"https://huggingface.co/enterprise\">\n \n</a><br>\n\n## When shouldn't I use Transformers?\n\n- This library is not a modular toolbox of building blocks for neural nets. The code in the model files is not refactored with additional abstractions on purpose, so that researchers can quickly iterate on each of the models without diving into additional abstractions/files.\n- The training API is optimized to work with PyTorch models provided by Transformers. For generic machine learning loops, you should use another library like [Accelerate](https://huggingface.co/docs/accelerate).\n- The [example scripts](https://github.com/huggingface/transformers/tree/main/examples) are only *examples*. They may not necessarily work out-of-the-box on your specific use case and you'll need to adapt the code for it to work.\n\n## 100 projects using Transformers\n\nTransformers is more than a toolkit to use pretrained models, it's a community of projects built around it and the\nHugging Face Hub. We want Transformers to enable developers, researchers, students, professors, engineers, and anyone\nelse to build their dream projects.\n\nIn order to celebrate Transformers 100,000 stars, we wanted to put the spotlight on the\ncommunity with the [awesome-transformers](./awesome-transformers.md) page which lists 100\nincredible projects built with Transformers.\n\nIf you own or use a project that you believe should be part of the list, please open a PR to add it!\n\n## Example models\n\nYou can test most of our models directly on their [Hub model pages](https://huggingface.co/models).\n\nExpand each modality below to see a few example models for various use cases.\n\n<details>\n<summary>Audio</summary>\n\n- Audio classification with [CLAP](https://huggingface.co/laion/clap-htsat-fused)\n- Automatic speech recognition with [Parakeet](https://huggingface.co/nvidia/parakeet-ctc-1.1b#transcribing-using-transformers-%F0%9F%A4%97), [Whisper](https://huggingface.co/openai/whisper-large-v3-turbo), [GLM-ASR](https://huggingface.co/zai-org/GLM-ASR-Nano-2512) and [Moonshine-Streaming](https://huggingface.co/UsefulSensors/moonshine-streaming-medium)\n- Keyword spotting with [Wav2Vec2](https://huggingface.co/superb/wav2vec2-base-superb-ks)\n- Speech to speech generation with [Moshi](https://huggingface.co/kyutai/moshiko-pytorch-bf16)\n- Text to audio with [MusicGen](https://huggingface.co/facebook/musicgen-large)\n- Text to speech with [CSM](https://huggingface.co/sesame/csm-1b)\n\n</details>\n\n<details>\n<summary>Computer vision</summary>\n\n- Automatic mask generation with [SAM](https://huggingface.co/facebook/sam-vit-base)\n- Depth estimation with [DepthPro](https://huggingface.co/apple/DepthPro-hf)\n- Image classification with [DINO v2](https://huggingface.co/facebook/dinov2-base)\n- Keypoint detection with [SuperPoint](https://huggingface.co/magic-leap-community/superpoint)\n- Keypoint matching with [SuperGlue](https://huggingface.co/magic-leap-community/superglue_outdoor)\n- Object detection with [RT-DETRv2](https://huggingface.co/PekingU/rtdetr_v2_r50vd)\n- Pose Estimation with [VitPose](https://huggingface.co/usyd-community/vitpose-base-simple)\n- Universal segmentation with [OneFormer](https://huggingface.co/shi-labs/oneformer_ade20k_swin_large)\n- Video classification with [VideoMAE](https://huggingface.co/MCG-NJU/videomae-large)\n\n</details>\n\n<details>\n<summary>Multimodal</summary>\n\n- Audio or text to text with [Voxtral](https://huggingface.co/mistralai/Voxtral-Mini-3B-2507), [Audio Flamingo](https://huggingface.co/nvidia/audio-flamingo-3-hf)\n- Document question answering with [LayoutLMv3](https://huggingface.co/microsoft/layoutlmv3-base)\n- Image or text to text with [Qwen-VL](https://huggingface.co/Qwen/Qwen2.5-VL-3B-Instruct)\n- Image captioning [BLIP-2](https://huggingface.co/Salesforce/blip2-opt-2.7b)\n- OCR-based document understanding with [GOT-OCR2](https://huggingface.co/stepfun-ai/GOT-OCR-2.0-hf)\n- Table question answering with [TAPAS](https://huggingface.co/google/tapas-base)\n- Unified multimodal understanding and generation with [Emu3](https://huggingface.co/BAAI/Emu3-Gen)\n- Vision to text with [Llava-OneVision](https://huggingface.co/llava-hf/llava-onevision-qwen2-0.5b-ov-hf)\n- Visual question answering with [Llava](https://huggingface.co/llava-hf/llava-1.5-7b-hf)\n- Visual referring expression segmentation with [Kosmos-2](https://huggingface.co/microsoft/kosmos-2-patch14-224)\n\n</details>\n\n<details>\n<summary>NLP</summary>\n\n- Masked word completion with [ModernBERT](https://huggingface.co/answerdotai/ModernBERT-base)\n- Named entity rec\n"
}
],
"json_schema": {
"title": "repo_knowledge_extraction",
"type": "object",
"additionalProperties": false,
"required": [
"repo_name",
"repo_url",
"repo_category",
"summary",
"learning_value",
"prerequisites",
"knowledge_points",
"suggested_learning_path",
"relevant_directories",
"tags"
],
"properties": {
"repo_name": {
"type": "string"
},
"repo_url": {
"type": "string"
},
"repo_category": {
"type": "string"
},
"summary": {
"type": "string"
},
"learning_value": {
"type": "string"
},
"prerequisites": {
"type": "array",
"items": {
"type": "string"
}
},
"knowledge_points": {
"type": "array",
"items": {
"type": "object",
"additionalProperties": false,
"required": [
"name",
"category",
"description",
"importance",
"evidence"
],
"properties": {
"name": {
"type": "string"
},
"category": {
"type": "string"
},
"description": {
"type": "string"
},
"importance": {
"type": "string"
},
"evidence": {
"type": "string"
}
}
}
},
"suggested_learning_path": {
"type": "array",
"items": {
"type": "string"
}
},
"relevant_directories": {
"type": "array",
"items": {
"type": "string"
}
},
"tags": {
"type": "array",
"items": {
"type": "string"
}
}
}
}
}
\ No newline at end of file
{
"repo_name": "langchain",
"repo_url": "https://github.com/langchain-ai/langchain",
"messages": [
{
"role": "system",
"content": "你是一个负责分析 GitHub 开源仓库的技术研究助手。你的任务是从 README、目录结构和仓库元信息中,提取适合后续培训、知识整理和项目分析使用的结构化知识点。输出必须严格符合给定 JSON Schema,不要输出额外解释,不要输出 Markdown。如果某个信息不能完全确定,可以基于 README 和目录结构做保守推断,但不要编造与仓库内容明显不符的信息。"
},
{
"role": "user",
"content": "请基于下面的 GitHub 仓库信息,提取结构化知识点。\n\n目标要求:\n1. 判断仓库类别,例如深度学习框架、Web 框架、LLM 应用框架、开发工具、数据平台等。\n2. 总结仓库的核心定位和学习价值。\n3. 提炼 5 到 8 个值得学习的知识点,每个知识点都要附带来源证据。\n4. 给出建议的前置知识和学习路径。\n5. 标出最值得关注的目录。\n\n仓库名称:langchain\n仓库链接:https://github.com/langchain-ai/langchain\n主要语言:Python\nStars:141638\n最近更新时间:2026-07-13T07:59:32Z\nmain_features:[\"LangChain ecosystem\", \"Why use LangChain?\"]\nmetadata:{\"owner\": \"langchain-ai\", \"default_branch\": \"master\", \"topics\": [\"agents\", \"ai\", \"ai-agents\", \"anthropic\", \"chatgpt\", \"deepagents\", \"enterprise\", \"framework\", \"gemini\", \"generative-ai\", \"langchain\", \"langgraph\", \"llm\", \"multiagent\", \"open-source\", \"openai\", \"pydantic\", \"python\", \"rag\", \"typescript\"]}\n\n目录结构摘录:\n├── .devcontainer\n│ ├── devcontainer.json\n│ ├── docker-compose.yaml\n│ └── README.md\n├── .github\n│ ├── actions\n│ │ └── uv_setup\n│ │ └── action.yml\n│ ├── images\n│ │ ├── logo-dark.svg\n│ │ └── logo-light.svg\n│ ├── ISSUE_TEMPLATE\n│ │ ├── bug-report.yml\n│ │ ├── config.yml\n│ │ ├── feature-request.yml\n│ │ ├── privileged.yml\n│ │ └── task.yml\n│ ├── scripts\n│ │ ├── check_diff.py\n│ │ ├── check_extras_sync.py\n│ │ ├── check_prerelease_dependencies.py\n│ │ ├── get_min_versions.py\n│ │ ├── pr-labeler-config.json\n│ │ ├── pr-labeler.js\n│ │ └── test_release_options.py\n│ ├── tools\n│ │ └── git-restore-mtime\n│ ├── workflows\n│ │ ├── _compile_integration_test.yml\n│ │ ├── _lint.yml\n│ │ ├── _refresh_model_profiles.yml\n│ │ ├── _release.yml\n│ │ ├── _test.yml\n│ │ ├── _test_pydantic.yml\n│ │ ├── _test_vcr.yml\n│ │ ├── auto-label-by-package.yml\n│ │ ├── block_fork_main_prs.yml\n│ │ ├── bump_uv_pin.yml\n│ │ ├── check_agents_sync.yml\n│ │ ├── check_diffs.yml\n│ │ ├── check_extras_sync.yml\n│ │ ├── check_release_deps.yml\n│ │ ├── check_versions.yml\n│ │ ├── close_unchecked_issues.yml\n│ │ ├── codspeed.yml\n│ │ ├── integration_tests.yml\n│ │ ├── pr_labeler.yml\n│ │ ├── pr_labeler_backfill.yml\n│ │ ├── pr_lint.yml\n│ │ ├── pr_lint_trailer.yml\n│ │ ├── refresh_model_profiles.yml\n│ │ ├── remove_waiting_on_author.yml\n│ │ ├── reopen_on_assignment.yml\n│ │ ├── require_issue_link.yml\n│ │ └── tag-external-issues.yml\n│ ├── CODEOWNERS\n│ ├── dependabot.yml\n│ └── PULL_REQUEST_TEMPLATE.md\n├── .vscode\n│ ├── extensions.json\n│ └── settings.json\n├── libs\n│ ├── core\n│ │ ├── langchain_core\n│ │ │ ├── _api\n│ │ │ │ ├── __init__.py\n│ │ │ │ ├── beta_decorator.py\n│ │ │ │ ├── deprecation.py\n│ │ │ │ ├── internal.py\n│ │ │ │ └── path.py\n│ │ │ ├── _security\n│ │ │ │ ├── __init__.py\n│ │ │ │ ├── _exceptions.py\n│ │ │ │ ├── _policy.py\n│ │ │ │ ├── _ssrf_protection.py\n│ │ │ │ └── _transport.py\n│ │ │ ├── callbacks\n│ │ │ │ ├── __init__.py\n│ │ │ │ ├── base.py\n│ │ │ │ ├── file.py\n│ │ │ │ ├── manager.py\n│ │ │ │ ├── stdout.py\n│ │ │ │ ├── streaming_stdout.py\n│ │ │ │ └── usage.py\n│ │ │ ├── document_loaders\n│ │ │ │ ├── __init__.py\n│ │ │ │ ├── base.py\n│ │ │ │ ├── blob_loaders.py\n│ │ │ │ └── langsmith.py\n│ │ │ ├── documents\n│ │ │ │ ├── __init__.py\n│ │ │ │ ├── base.py\n│ │ │ │ ├── compressor.py\n│ │ │ │ └── transformers.py\n│ │ │ ├── embeddings\n│ │ │ │ ├── __init__.py\n│ │ │ │ ├── embeddings.py\n│ │ │ │ └── fake.py\n│ │ │ ├── example_selectors\n│ │ │ │ ├── __init__.py\n│ │ │ │ ├── base.py\n│ │ │ │ ├── length_based.py\n│ │ │ │ └── semantic_similarity.py\n│ │ │ ├── indexing\n│ │ │ │ ├── __init__.py\n│ │ │ │ ├── api.py\n│ │ │ │ ├── base.py\n│ │ │ │ └── in_memory.py\n│ │ │ ├── language_models\n│ │ │ │ ├── __init__.py\n│ │ │ │ ├── _compat_bridge.py\n│ │ │ │ ├── _utils.py\n│ │ │ │ ├── base.py\n│ │ │ │ ├── chat_model_stream.py\n│ │ │ │ ├── chat_models.py\n│ │ │ │ ├── fake.py\n│ │ │ │ ├── fake_chat_models.py\n│ │ │ │ ├── llms.py\n│ │ │ │ └── model_profile.py\n│ │ │ ├── load\n\nREADME 摘录:\n<div align=\"center\">\n <a href=\"https://docs.langchain.com/oss/python/langchain/overview\">\n \n </a>\n</div>\n\n<div align=\"center\">\n <h3>The agent engineering platform.</h3>\n</div>\n\n<div align=\"center\">\n <a href=\"https://opensource.org/licenses/MIT\" target=\"_blank\"></a>\n <a href=\"https://pypistats.org/packages/langchain\" target=\"_blank\"></a>\n <a href=\"https://pypi.org/project/langchain/#history\" target=\"_blank\"></a>\n <a href=\"https://x.com/langchain_oss\" target=\"_blank\"></a>\n</div>\n\n<br>\n\nLangChain is a framework for building agents and LLM-powered applications. It helps you chain together interoperable components and third-party integrations to simplify AI application development — all while future-proofing decisions as the underlying technology evolves.\n\n> [!TIP]\n> Just getting started? Check out **[Deep Agents](http://docs.langchain.com/oss/python/deepagents/)** — a higher-level package built on LangChain for agents that have built-in capabilites for common usage patterns such as planning, subagents, file system usage, and more.\n\n## Quickstart\n\nIf you're looking for more advanced customization or agent orchestration, check out [LangGraph](https://github.com/langchain-ai/langgraph), our framework for building controllable agent workflows.\n\nFor an equivalent JS/TS library, check out [LangChain.js](https://github.com/langchain-ai/langchainjs).\n\n> [!TIP]\n> For developing, debugging, and deploying AI agents and LLM applications, see [LangSmith](https://docs.langchain.com/langsmith/home).\n\n## LangChain ecosystem\n\nWhile the LangChain framework can be used standalone, it also integrates seamlessly with any LangChain product, giving developers a full suite of tools when building LLM applications.\n\n- **[Deep Agents](http://docs.langchain.com/oss/python/deepagents/)** — Build agents that can plan, use subagents, and leverage file systems for complex tasks\n- **[LangGraph](https://docs.langchain.com/oss/python/langgraph/overview)** — Build agents that can reliably handle complex tasks with our low-level agent orchestration framework\n- **[Integrations](https://docs.langchain.com/oss/python/integrations/providers/overview)** — Chat & embedding models, tools & toolkits, and more\n- **[LangSmith](https://www.langchain.com/langsmith)** — Agent evals, observability, and debugging for LLM apps\n- **[LangSmith Deployment](https://docs.langchain.com/langsmith/deployments)** — Deploy and scale agents with a purpose-built platform for long-running, stateful workflows\n\n## Why use LangChain?\n\nLangChain helps developers build applications powered by LLMs through a standard interface for models, embeddings, vector stores, and more.\n\n- **Real-time data augmentation** — Easily connect LLMs to diverse data sources and external/internal systems, drawing from LangChain's vast library of integrations with model providers, tools, vector stores, retrievers, and more\n- **Model interoperability** — Swap models in and out as your engineering team experiments to find the best choice for your application's needs. As the industry frontier evolves, adapt quickly — LangChain's abstractions keep you moving without losing momentum\n- **Rapid prototyping** — Quickly build and iterate on LLM applications with LangChain's modular, component-based architecture. Test different approaches and workflows without rebuilding from scratch, accelerating your development cycle\n- **Production-ready features** — Deploy reliable applications with built-in support for monitoring, evaluation, and debugging through integrations like LangSmith. Scale with confidence using battle-tested patterns and best practices\n- **Vibrant community and ecosystem** — Leverage a rich ecosystem of integrations, templates, and community-contributed components. Benefit from continuous improvements and stay up-to-date with the latest AI developments through an active open-source community\n- **Flexible abstraction layers** — Work at the level of abstraction that suits your needs — from high-level chains for quick starts to low-level components for fine-grained control. LangChain grows with your application's complexity\n\n---\n\n## Resources\n\n- [Documentation](https://docs.langchain.com/oss/python/langchain/overview) — conceptual overviews and guides\n- [LangChain ecosystem overview](https://docs.langchain.com/oss/python/concepts/products) — how LangChain, LangGraph, and Deep Agents fit together\n- [API reference](https://reference.langchain.com/python) — complete reference for all public classes, functions, and types\n- [Discussions](https://forum.langchain.com/c/oss-product-help-lc-and-lg/langchain/14) — community forum for technical questions, ideas, and feedback\n- [LangChain Academy](https://academy.langchain.com/) — comprehensive, free courses on LangChain libraries and products, made by the LangChain team\n- [Contributing Guide](https://docs.langchain.com/oss/python/contributing/overview) — how to contribute and find good first issues\n- [Code of Conduct](https://github.com/langchain-ai/langchain/?tab=coc-ov-file) — community guidelines and standards\n"
}
],
"json_schema": {
"title": "repo_knowledge_extraction",
"type": "object",
"additionalProperties": false,
"required": [
"repo_name",
"repo_url",
"repo_category",
"summary",
"learning_value",
"prerequisites",
"knowledge_points",
"suggested_learning_path",
"relevant_directories",
"tags"
],
"properties": {
"repo_name": {
"type": "string"
},
"repo_url": {
"type": "string"
},
"repo_category": {
"type": "string"
},
"summary": {
"type": "string"
},
"learning_value": {
"type": "string"
},
"prerequisites": {
"type": "array",
"items": {
"type": "string"
}
},
"knowledge_points": {
"type": "array",
"items": {
"type": "object",
"additionalProperties": false,
"required": [
"name",
"category",
"description",
"importance",
"evidence"
],
"properties": {
"name": {
"type": "string"
},
"category": {
"type": "string"
},
"description": {
"type": "string"
},
"importance": {
"type": "string"
},
"evidence": {
"type": "string"
}
}
}
},
"suggested_learning_path": {
"type": "array",
"items": {
"type": "string"
}
},
"relevant_directories": {
"type": "array",
"items": {
"type": "string"
}
},
"tags": {
"type": "array",
"items": {
"type": "string"
}
}
}
}
}
\ No newline at end of file
{
"repo_name": "vscode",
"repo_url": "https://github.com/microsoft/vscode",
"messages": [
{
"role": "system",
"content": "你是一个负责分析 GitHub 开源仓库的技术研究助手。你的任务是从 README、目录结构和仓库元信息中,提取适合后续培训、知识整理和项目分析使用的结构化知识点。输出必须严格符合给定 JSON Schema,不要输出额外解释,不要输出 Markdown。如果某个信息不能完全确定,可以基于 README 和目录结构做保守推断,但不要编造与仓库内容明显不符的信息。"
},
{
"role": "user",
"content": "请基于下面的 GitHub 仓库信息,提取结构化知识点。\n\n目标要求:\n1. 判断仓库类别,例如深度学习框架、Web 框架、LLM 应用框架、开发工具、数据平台等。\n2. 总结仓库的核心定位和学习价值。\n3. 提炼 5 到 8 个值得学习的知识点,每个知识点都要附带来源证据。\n4. 给出建议的前置知识和学习路径。\n5. 标出最值得关注的目录。\n\n仓库名称:vscode\n仓库链接:https://github.com/microsoft/vscode\n主要语言:TypeScript\nStars:187487\n最近更新时间:2026-07-13T08:02:45Z\nmain_features:[\"The Repository\", \"Visual Studio Code\", \"Feedback\", \"Related Projects\", \"Bundled Extensions\", \"Development Container\", \"Code of Conduct\"]\nmetadata:{\"owner\": \"microsoft\", \"default_branch\": \"main\", \"topics\": [\"editor\", \"electron\", \"microsoft\", \"typescript\", \"visual-studio-code\"]}\n\n目录结构摘录:\n├── .agents\n│ └── skills\n│ └── launch\n│ ├── scripts\n│ │ ├── launch.sh\n│ │ └── monaco-paste.sh\n│ └── SKILL.md\n├── .config\n│ ├── 1espt\n│ │ └── PipelineAutobaseliningConfig.yml\n│ ├── guardian\n│ │ └── .gdnsuppress\n│ └── configuration.winget\n├── .devcontainer\n│ ├── devcontainer-lock.json\n│ ├── devcontainer.json\n│ ├── Dockerfile\n│ ├── install-vscode.sh\n│ ├── post-create.sh\n│ └── README.md\n├── .eslint-plugin-local\n│ ├── tests\n│ │ ├── code-no-observable-get-in-reactive-context-test.ts\n│ │ └── code-no-reader-after-await-test.ts\n│ ├── code-amd-node-module.ts\n│ ├── code-declare-service-brand.ts\n│ ├── code-ensure-no-disposables-leak-in-test.ts\n│ ├── code-import-patterns.ts\n│ ├── code-layering.ts\n│ ├── code-limited-top-functions.ts\n│ ├── code-must-use-result.ts\n│ ├── code-must-use-super-dispose.ts\n│ ├── code-no-accessor-after-await.ts\n│ ├── code-no-any-casts.ts\n│ ├── code-no-dangerous-type-assertions.ts\n│ ├── code-no-declare-const-enum.ts\n│ ├── code-no-deep-import-of-internal.ts\n│ ├── code-no-direct-gulp-import.ts\n│ ├── code-no-global-document-listener.ts\n│ ├── code-no-http-import.ts\n│ ├── code-no-icons-in-localized-strings.ts\n│ ├── code-no-in-operator.ts\n│ ├── code-no-localization-template-literals.ts\n│ ├── code-no-localized-model-description.ts\n│ ├── code-no-new-javascript-files.ts\n│ ├── code-no-nls-in-standalone-editor.ts\n│ ├── code-no-observable-get-in-reactive-context.ts\n│ ├── code-no-potentially-unsafe-disposables.ts\n│ ├── code-no-reader-after-await.ts\n│ ├── code-no-runtime-import.ts\n│ ├── code-no-standalone-editor.ts\n│ ├── code-no-static-node-module-import.ts\n│ ├── code-no-static-self-ref.ts\n│ ├── code-no-telemetry-common-property.ts\n│ ├── code-no-test-async-suite.ts\n│ ├── code-no-test-only.ts\n│ ├── code-no-unexternalized-strings.ts\n│ ├── code-no-untyped-meta-access.ts\n│ ├── code-no-unused-expressions.ts\n│ ├── code-parameter-properties-must-have-explicit-accessibility.ts\n│ ├── code-policy-localization-key-match.ts\n│ ├── code-translation-remind.ts\n│ ├── index.ts\n│ ├── package.json\n│ ├── README.md\n│ ├── tsconfig.json\n│ ├── utils.ts\n│ ├── vscode-dts-cancellation.ts\n│ ├── vscode-dts-create-func.ts\n│ ├── vscode-dts-event-naming.ts\n│ ├── vscode-dts-interface-naming.ts\n│ ├── vscode-dts-literal-or-types.ts\n│ ├── vscode-dts-provider-naming.ts\n│ ├── vscode-dts-string-type-literals.ts\n│ ├── vscode-dts-use-export.ts\n│ ├── vscode-dts-use-thenable.ts\n│ └── vscode-dts-vscode-in-comments.ts\n├── .github\n│ ├── actions\n│ │ ├── restore-node-modules\n│ │ │ └── action.yml\n│ │ └── save-node-modules\n│ │ └── action.yml\n│ ├── agents\n│ │ ├── data.md\n│ │ ├── demonstrate.md\n│ │ └── sessions.md\n│ ├── commands\n│ │ └── codespaces_issue.yml\n│ ├── endgame\n│ │ └── insiders.yml\n│ ├── instructions\n│ │ ├── resources\n│ │ │ ├── interactive\n│ │ │ │ ├── interactive.editor.drawio.svg\n│ │ │ │ ├── interactive.eh.drawio.svg\n│ │ │ │ └── interactive.model.resolution.drawio.svg\n│ │ │ └── notebook\n│ │ │ ├── cell-resize-above-viewport.drawio.svg\n│ │ │ ├── hybrid-find.drawio.svg\n│ │ │ └── viewport-rendering.drawio.svg\n│ │ ├── accessibility.instructions.md\n│ │ ├── agentHostTesting.instructions.md\n│ │ ├── ai-customization.instructions.md\n│ │ ├── best-practices.instructions.md\n│ │ ├── buildNext.instructions.md\n│ │ ├── chat.instructions.md\n│ │ ├── coding-guidelines.instructions.md\n│ │ ├── committing.instructions.md\n│ │ ├── design-philosophy.instructions.md\n│ │ ├── design-tokens.instructions.md\n│ │ ├── disposable.instructions.md\n│ │ ├── interactive.instructions.md\n│ │ ├── kusto.instructions.md\n│ │ ├── learnings.instructions.md\n│ │ ├── notebook.instructions.md\n│ │ ├── observables.instructions.md\n│ │ ├── oss-third-party-notices.instructions.md\n│ │ ├── oss.instructions.md\n│ │ ├── sessions.instructions.md\n\nREADME 摘录:\n# Visual Studio Code - Open Source (\"Code - OSS\")\n[](https://github.com/microsoft/vscode/issues?q=is%3Aopen+is%3Aissue+label%3Afeature-request+sort%3Areactions-%2B1-desc)\n[](https://github.com/microsoft/vscode/issues?utf8=✓&q=is%3Aissue+is%3Aopen+label%3Abug)\n[](https://gitter.im/Microsoft/vscode)\n\n## The Repository\n\nThis repository (\"`Code - OSS`\") is where we (Microsoft) develop the [Visual Studio Code](https://code.visualstudio.com) product together with the community. Not only do we work on code and issues here, but we also publish our [roadmap](https://github.com/microsoft/vscode/wiki/Roadmap), [monthly iteration plans](https://github.com/microsoft/vscode/wiki/Iteration-Plans), and our [endgame plans](https://github.com/microsoft/vscode/wiki/Running-the-Endgame). This source code is available to everyone under the standard [MIT license](https://github.com/microsoft/vscode/blob/main/LICENSE.txt).\n\n## Visual Studio Code\n\n<p align=\"center\">\n \n</p>\n\n[Visual Studio Code](https://code.visualstudio.com) is a distribution of the `Code - OSS` repository with Microsoft-specific customizations released under a traditional [Microsoft product license](https://code.visualstudio.com/License/).\n\n[Visual Studio Code](https://code.visualstudio.com) combines the simplicity of a code editor with what developers need for their core edit-build-debug cycle. It provides comprehensive code editing, navigation, and understanding support along with lightweight debugging, a rich extensibility model, and lightweight integration with existing tools.\n\nVisual Studio Code is updated monthly with new features and bug fixes. You can download it for Windows, macOS, and Linux on [Visual Studio Code's website](https://code.visualstudio.com/Download). To get the latest releases every day, install the [Insiders build](https://code.visualstudio.com/insiders).\n\n## Contributing\n\nThere are many ways in which you can participate in this project, for example:\n\n* [Submit bugs and feature requests](https://github.com/microsoft/vscode/issues), and help us verify as they are checked in\n* Review [source code changes](https://github.com/microsoft/vscode/pulls)\n* Review the [documentation](https://github.com/microsoft/vscode-docs) and make pull requests for anything from typos to new content.\n\nIf you are interested in fixing issues and contributing directly to the code base,\nplease see the document [How to Contribute](https://github.com/microsoft/vscode/wiki/How-to-Contribute), which covers the following:\n\n* [How to build and run from source](https://github.com/microsoft/vscode/wiki/How-to-Contribute)\n* [The development workflow, including debugging and running tests](https://github.com/microsoft/vscode/wiki/How-to-Contribute#debugging)\n* [Coding guidelines](https://github.com/microsoft/vscode/wiki/Coding-Guidelines)\n* [Submitting pull requests](https://github.com/microsoft/vscode/wiki/How-to-Contribute#pull-requests)\n* [Finding an issue to work on](https://github.com/microsoft/vscode/wiki/How-to-Contribute#where-to-contribute)\n* [Contributing to translations](https://aka.ms/vscodeloc)\n\n## Feedback\n\n* Ask a question on [Stack Overflow](https://stackoverflow.com/questions/tagged/vscode)\n* [Request a new feature](CONTRIBUTING.md)\n* Upvote [popular feature requests](https://github.com/microsoft/vscode/issues?q=is%3Aopen+is%3Aissue+label%3Afeature-request+sort%3Areactions-%2B1-desc)\n* [File an issue](https://github.com/microsoft/vscode/issues)\n* Connect with the extension author community on [GitHub Discussions](https://github.com/microsoft/vscode-discussions/discussions) or [Slack](https://aka.ms/vscode-dev-community)\n* Follow [@code](https://x.com/code) and let us know what you think!\n\nSee our [wiki](https://github.com/microsoft/vscode/wiki/Feedback-Channels) for a description of each of these channels and information on some other available community-driven channels.\n\n## Related Projects\n\nMany of the core components and extensions to VS Code live in their own repositories on GitHub. For example, the [node debug adapter](https://github.com/microsoft/vscode-node-debug) and the [mono debug adapter](https://github.com/microsoft/vscode-mono-debug) repositories are separate from each other. For a complete list, please visit the [Related Projects](https://github.com/microsoft/vscode/wiki/Related-Projects) page on our [wiki](https://github.com/microsoft/vscode/wiki).\n\n## Bundled Extensions\n\nVS Code includes a set of built-in extensions located in the [extensions](extensions) folder, including grammars and snippets for many languages. Extensions that provide rich language support (inline suggestions, Go to Definition) for a language have the suffix `language-features`. For example, the `json` extension provides coloring for `JSON` and the `json-language-features` extension provides rich language support for `JSON`.\n\n## Development Container\n\nThis repository includes a Visual Studio Code Dev Containers / GitHub Codespaces development container.\n\n* For [Dev Containers](https://aka.ms/vscode-remote/download/containers), use the **Dev Containers: Clone Repository in Container Volume...** command which creates a Docker volume for better disk I/O on macOS and Windows.\n * If you already have VS Code and Docker installed, you can also click [here](https://vscode.dev/redirect?url=vscode://ms-vscode-remote.remote-containers/cloneInVolume?url=https://github.com/microsoft/vscode) to get started. This will cause VS Code to automatically install the Dev Containers extension if needed, clone the source code into a container volume, and spin up a dev container for use.\n\n* For Codespaces, install the [GitHub Codespaces](https://marketplace.visualstudio.com/items?itemName=GitHub.codespaces) extension in VS Code, and use the **Codespaces: Create New Codespace** command.\n\nDocker / the Codespace should have at least **4 cores and 6 GB of RAM (8 GB recommended)** to run a full build. See the [development container README](.devcontainer/README.md) for more information.\n\n## Code of Conduct\n\nThis project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.\n\n## License\n\nCopyright (c) Microsoft Corporation. All rights reserved.\n\nLicensed under the [MIT](LICENSE.txt) license.\n"
}
],
"json_schema": {
"title": "repo_knowledge_extraction",
"type": "object",
"additionalProperties": false,
"required": [
"repo_name",
"repo_url",
"repo_category",
"summary",
"learning_value",
"prerequisites",
"knowledge_points",
"suggested_learning_path",
"relevant_directories",
"tags"
],
"properties": {
"repo_name": {
"type": "string"
},
"repo_url": {
"type": "string"
},
"repo_category": {
"type": "string"
},
"summary": {
"type": "string"
},
"learning_value": {
"type": "string"
},
"prerequisites": {
"type": "array",
"items": {
"type": "string"
}
},
"knowledge_points": {
"type": "array",
"items": {
"type": "object",
"additionalProperties": false,
"required": [
"name",
"category",
"description",
"importance",
"evidence"
],
"properties": {
"name": {
"type": "string"
},
"category": {
"type": "string"
},
"description": {
"type": "string"
},
"importance": {
"type": "string"
},
"evidence": {
"type": "string"
}
}
}
},
"suggested_learning_path": {
"type": "array",
"items": {
"type": "string"
}
},
"relevant_directories": {
"type": "array",
"items": {
"type": "string"
}
},
"tags": {
"type": "array",
"items": {
"type": "string"
}
}
}
}
}
\ No newline at end of file
{
"repo_name": "pytorch",
"repo_url": "https://github.com/pytorch/pytorch",
"messages": [
{
"role": "system",
"content": "你是一个负责分析 GitHub 开源仓库的技术研究助手。你的任务是从 README、目录结构和仓库元信息中,提取适合后续培训、知识整理和项目分析使用的结构化知识点。输出必须严格符合给定 JSON Schema,不要输出额外解释,不要输出 Markdown。如果某个信息不能完全确定,可以基于 README 和目录结构做保守推断,但不要编造与仓库内容明显不符的信息。"
},
{
"role": "user",
"content": "请基于下面的 GitHub 仓库信息,提取结构化知识点。\n\n目标要求:\n1. 判断仓库类别,例如深度学习框架、Web 框架、LLM 应用框架、开发工具、数据平台等。\n2. 总结仓库的核心定位和学习价值。\n3. 提炼 5 到 8 个值得学习的知识点,每个知识点都要附带来源证据。\n4. 给出建议的前置知识和学习路径。\n5. 标出最值得关注的目录。\n\n仓库名称:pytorch\n仓库链接:https://github.com/pytorch/pytorch\n主要语言:Python\nStars:101788\n最近更新时间:2026-07-13T08:07:53Z\nmain_features:[\"Tensor computation (like NumPy) with strong GPU acceleration\", \"Deep neural networks built on a tape-based autograd system\", \"A replacement for NumPy to use the power of GPUs\", \"A deep learning research platform that provides maximum flexibility and speed\"]\nmetadata:{\"owner\": \"pytorch\", \"default_branch\": \"main\", \"topics\": [\"autograd\", \"deep-learning\", \"gpu\", \"machine-learning\", \"neural-network\", \"numpy\", \"python\", \"tensor\"]}\n\n目录结构摘录:\n├── .ci\n│ ├── caffe2\n│ │ ├── common.sh\n│ │ ├── README.md\n│ │ └── test.sh\n│ ├── docker\n│ │ ├── almalinux\n│ │ │ ├── build.sh\n│ │ │ └── Dockerfile\n│ │ ├── ci_commit_pins\n│ │ │ ├── executorch.txt\n│ │ │ ├── halide.txt\n│ │ │ ├── huggingface-requirements.txt\n│ │ │ ├── jax.txt\n│ │ │ ├── nccl-cu126.txt\n│ │ │ ├── nccl.txt\n│ │ │ ├── rocm-composable-kernel.txt\n│ │ │ ├── rocm-origami.txt\n│ │ │ ├── timm.txt\n│ │ │ ├── torchbench.txt\n│ │ │ ├── triton-cpu.txt\n│ │ │ ├── triton-xpu.txt\n│ │ │ └── triton.txt\n│ │ ├── common\n│ │ │ ├── cache_vision_models.sh\n│ │ │ ├── common_utils.sh\n│ │ │ ├── install_acl.sh\n│ │ │ ├── install_amdsmi.sh\n│ │ │ ├── install_base.sh\n│ │ │ ├── install_cache.sh\n│ │ │ ├── install_clang.sh\n│ │ │ ├── install_conda.sh\n│ │ │ ├── install_conda_docker.sh\n│ │ │ ├── install_cpython.sh\n│ │ │ ├── install_cuda.sh\n│ │ │ ├── install_cudss.sh\n│ │ │ ├── install_cusparselt.sh\n│ │ │ ├── install_docs_reqs.sh\n│ │ │ ├── install_executorch.sh\n│ │ │ ├── install_gcc.sh\n│ │ │ ├── install_halide.sh\n│ │ │ ├── install_inductor_benchmark_deps.sh\n│ │ │ ├── install_jax.sh\n│ │ │ ├── install_jni.sh\n│ │ │ ├── install_lcov.sh\n│ │ │ ├── install_libgomp.sh\n│ │ │ ├── install_libpng.sh\n│ │ │ ├── install_linter.sh\n│ │ │ ├── install_magma.sh\n│ │ │ ├── install_magma_conda.sh\n│ │ │ ├── install_mingw.sh\n│ │ │ ├── install_miopen.sh\n│ │ │ ├── install_mkl.sh\n│ │ │ ├── install_mnist.sh\n│ │ │ ├── install_nccl.sh\n│ │ │ ├── install_nvpl.sh\n│ │ │ ├── install_onnx.sh\n│ │ │ ├── install_openblas.sh\n│ │ │ ├── install_openmpi.sh\n│ │ │ ├── install_patchelf.sh\n│ │ │ ├── install_python.sh\n│ │ │ ├── install_rocm.sh\n│ │ │ ├── install_rocm_drm.sh\n│ │ │ ├── install_rocm_magma.sh\n│ │ │ ├── install_rocSHMEM.sh\n│ │ │ ├── install_torch_tpu.sh\n│ │ │ ├── install_triton.sh\n│ │ │ ├── install_user.sh\n│ │ │ ├── install_xpu.sh\n│ │ │ ├── patch_libstdc.sh\n│ │ │ └── requirements_tpu.txt\n│ │ ├── java\n│ │ │ └── jni.h\n│ │ ├── linter\n│ │ │ └── Dockerfile\n│ │ ├── linter-cuda\n│ │ │ └── Dockerfile\n│ │ ├── manywheel\n│ │ │ ├── s390_scripts\n│ │ │ │ ├── build.sh\n│ │ │ │ └── build_utils.sh\n│ │ │ ├── build.sh\n│ │ │ ├── Dockerfile_2_28\n│ │ │ ├── Dockerfile_2_28_aarch64\n│ │ │ ├── Dockerfile_cuda_aarch64\n│ │ │ └── Dockerfile_s390x\n│ │ ├── ubuntu\n│ │ │ └── Dockerfile\n│ │ ├── ubuntu-cross-riscv\n│ │ │ └── Dockerfile\n│ │ ├── ubuntu-rocm\n│ │ │ ├── .gitignore\n│ │ │ └── Dockerfile\n│ │ ├── ubuntu-xpu\n│ │ │ └── Dockerfile\n│ │ ├── build.sh\n│ │ ├── README.md\n│ │ ├── requirements-ci.txt\n│ │ ├── requirements-docs.txt\n│ │ ├── triton_version.txt\n│ │ └── triton_xpu_version.txt\n│ ├── flash-attention\n│ │ └── build.sh\n│ ├── libtorch\n│ │ ├── build.sh\n│ │ └── extract_libtorch_from_wheel.py\n│ ├── lumen_cli\n│ │ ├── cli\n│ │ │ ├── build_cli\n│ │ │ │ ├── __init__.py\n│ │ │ │ └── register_build.py\n│ │ │ ├── lib\n│ │ │ │ ├── common\n│ │ │ │ │ ├── cli_helper.py\n│ │ │ │ │ ├── docker_helper.py\n│ │ │ │ │ ├── envs_helper.py\n│ │ │ │ │ ├── gh_summary.py\n│ │ │ │ │ ├── git_helper.py\n│ │ │ │ │ ├── logger.py\n│ │ │ │ │ ├── path_helper.py\n\nREADME 摘录:\n--------------------------------------------------------------------------------\n\nPyTorch is a Python package that provides two high-level features:\n- Tensor computation (like NumPy) with strong GPU acceleration\n- Deep neural networks built on a tape-based autograd system\n\nYou can reuse your favorite Python packages such as NumPy, SciPy, and Cython to extend PyTorch when needed.\n\nOur trunk health (Continuous Integration signals) can be found at [hud.pytorch.org](https://hud.pytorch.org/ci/pytorch/pytorch/main).\n\n<!-- toc -->\n\n- [More About PyTorch](#more-about-pytorch)\n - [A GPU-Ready Tensor Library](#a-gpu-ready-tensor-library)\n - [Dynamic Neural Networks: Tape-Based Autograd](#dynamic-neural-networks-tape-based-autograd)\n - [Python First](#python-first)\n - [Imperative Experiences](#imperative-experiences)\n - [Fast and Lean](#fast-and-lean)\n - [Extensions Without Pain](#extensions-without-pain)\n- [Installation](#installation)\n - [Binaries](#binaries)\n - [NVIDIA Jetson Platforms](#nvidia-jetson-platforms)\n - [From Source](#from-source)\n - [Prerequisites](#prerequisites)\n - [NVIDIA CUDA Support](#nvidia-cuda-support)\n - [AMD ROCm Support](#amd-rocm-support)\n - [Intel GPU Support](#intel-gpu-support)\n - [Get the PyTorch Source](#get-the-pytorch-source)\n - [Install Dependencies](#install-dependencies)\n - [Install PyTorch](#install-pytorch)\n - [Adjust Build Options (Optional)](#adjust-build-options-optional)\n - [Docker Image](#docker-image)\n - [Using pre-built images](#using-pre-built-images)\n - [Building the image yourself](#building-the-image-yourself)\n - [Building the Documentation](#building-the-documentation)\n - [Troubleshooting CI Errors](#troubleshooting-ci-errors)\n - [Building a PDF](#building-a-pdf)\n - [Previous Versions](#previous-versions)\n- [Getting Started](#getting-started)\n- [Resources](#resources)\n- [Communication](#communication)\n- [Releases and Contributing](#releases-and-contributing)\n- [The Team](#the-team)\n- [License](#license)\n\n<!-- tocstop -->\n\n## More About PyTorch\n\n[Learn the basics of PyTorch](https://pytorch.org/tutorials/beginner/basics/intro.html)\n\nAt a granular level, PyTorch is a library that consists of the following components:\n\n| Component | Description |\n| ---- | --- |\n| [**torch**](https://pytorch.org/docs/stable/torch.html) | A Tensor library like NumPy, with strong GPU support |\n| [**torch.autograd**](https://pytorch.org/docs/stable/autograd.html) | A tape-based automatic differentiation library that supports all differentiable Tensor operations in torch |\n| [**torch.jit**](https://pytorch.org/docs/stable/jit.html) | A compilation stack (TorchScript) to create serializable and optimizable models from PyTorch code |\n| [**torch.nn**](https://pytorch.org/docs/stable/nn.html) | A neural networks library deeply integrated with autograd designed for maximum flexibility |\n| [**torch.multiprocessing**](https://pytorch.org/docs/stable/multiprocessing.html) | Python multiprocessing, but with magical memory sharing of torch Tensors across processes. Useful for data loading and Hogwild training |\n| [**torch.utils**](https://pytorch.org/docs/stable/data.html) | DataLoader and other utility functions for convenience |\n\nUsually, PyTorch is used either as:\n\n- A replacement for NumPy to use the power of GPUs.\n- A deep learning research platform that provides maximum flexibility and speed.\n\nElaborating Further:\n\n### A GPU-Ready Tensor Library\n\nIf you use NumPy, then you have used Tensors (a.k.a. ndarray).\n\nPyTorch provides Tensors that can live either on the CPU or the GPU and accelerates the\ncomputation by a huge amount.\n\nWe provide a wide variety of tensor routines to accelerate and fit your scientific computation needs\nsuch as slicing, indexing, mathematical operations, linear algebra, reductions.\nAnd they are fast!\n\n### Dynamic Neural Networks: Tape-Based Autograd\n\nPyTorch has a unique way of building neural networks: using and replaying a tape recorder.\n\nMost frameworks such as TensorFlow, Theano, Caffe, and CNTK have a static view of the world.\nOne has to build a neural network and reuse the same structure again and again.\nChanging the way the network behaves means that one has to start from scratch.\n\nWith PyTorch, we use a technique called reverse-mode auto-differentiation, which allows you to\nchange the way your network behaves arbitrarily with zero lag or overhead. Our inspiration comes\nfrom several research papers on this topic, as well as current and past work such as\n[torch-autograd](https://github.com/twitter/torch-autograd),\n[autograd](https://github.com/HIPS/autograd),\n[Chainer](https://chainer.org), etc.\n\nWhile this technique is not unique to PyTorch, it's one of the fastest implementations of it to date.\nYou get the best of speed and flexibility for your crazy research.\n\n### Python First\n\nPyTorch is not a Python binding into a monolithic C++ framework.\nIt is built to be deeply integrated into Python.\nYou can use it naturally like you would use [NumPy](https://www.numpy.org/) / [SciPy](https://www.scipy.org/) / [scikit-learn](https://scikit-learn.org) etc.\nYou can write your new neural network layers in Python itself, using your favorite libraries\nand use packages such as [Cython](https://cython.org/) and [Numba](http://numba.pydata.org/).\nOur goal is to not reinvent the wheel where appropriate.\n\n### Imperative Experiences\n\nPyTorch is designed to be intuitive, linear in thought, and easy to use.\nWhen you execute a line of code, it gets executed. There isn't an asynchronous view of the world.\nWhen you drop into a debugger or receive error messages and stack traces, understanding them is straightforward.\nThe stack trace points to exactly where your code was defined.\nWe hope you never spend hours debugging your code because of bad stack traces or asynchronous and opaque execution engines.\n\n### Fast and Lean\n\nPyTorch has minimal framework overhead. We integrate acceleration libraries\nsuch as [Intel MKL](https://software.intel.com/mkl) and NVIDIA ([cuDNN](https://developer.nvidia.com/cudnn), [NCCL](https://developer.nvidia.com/nccl)) to maximize speed.\nAt the core, its CPU and GPU Tensor and neural network backends\nare mature and have been tested for years.\n\nHence, PyTorch is quite fast — whether you run small or large neural networks.\n\nThe memory usage in PyTorch is extremely efficient compared to Torch or some of the alternatives.\nWe've written custom memory allocators for the GPU to make sure that\nyour deep learning models are maximally memory efficient.\nThis enables you to train bigger deep learning models than before.\n\n### Extensions Without Pain\n\nWriting new neural network modules, or interfacing with PyTorch's Tensor API, was designed to be straightforward\nand with minimal abstractions.\n\nYou can write new neural network layers in Python using the torch API\n[or your favorite NumPy-based libraries such as SciPy](https://pytorch.org/tutorials/advanced/numpy_extensions_tutorial.html).\n\nIf you want to write your layers in C/C++, we provide a convenient extension API that is efficient and with minimal boilerplate.\nNo wrapper code needs to be written. You can see [a tutorial here](https://pytorch.org/tutorials/advanced/cpp_extension.html) and [an example here](https://github.com/pytorch/extension-cpp).\n\n## Installation\n\n### Binaries\nCommands to install binaries via Conda or pip wheels are on our website: [https://pytorch.org/get-started/locally/](https://pytorch.org/get-started/locally/)\n\n#### NVIDIA Jetson Platforms\n\nPython wheels for NVIDIA's Jetson Nano, Jetson TX1/TX2, Jetson Xavier NX/AGX, and Jetson AGX Orin are provided [here](https://forums.developer.nvidia.com/t/pytorch-for-jetson-version-1-10-now-available/72048) and the L4T container is published [here](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/l4t-pytorch)\n\nThey require JetPack 4.2 and above, and [@dusty-nv](https://github.com/dusty-nv) and [@ptrblck](https://github.com/ptrblck) are maintaining them.\n\n### From Source\n\n#### Prerequisites\nIf you are installing from source, you will need:\n- Python 3.10 or later\n- A compiler that fully supports C++20, such as clang or gcc (gcc 11.3.0 or newer is required, on Linux)\n- Visual Studio or Visual Studio Build Tool (Windows only)\n- At least 10 GB of free disk space\n- 30-60 minutes for the initial build (subsequent rebuilds are much faster)\n\n\\* PyTorch CI uses Visual C++ BuildTools, which come with Visual Studio Enterprise,\nProfessional, or Community Editions. You can also install the build tools from\nhttps://visualstudio.microsoft.com/visual-cpp-build-tools/. The build tools *do not*\ncome with Visual Studio Code by default.\n\nAn example of environment setup is shown below:\n\n* Linux:\n\n* Windows:\n\nA conda environment is not required. You can also do a PyTorch build in a\nstandard virtual environment, e.g., created with tools like `uv`, provided\nyour system has installed all the necessary dependencies unavailable as pip\npackages (e.g., CUDA, MKL.)\n\n##### NVIDIA CUDA Support\nIf you want to compile with CUDA support, [select a supported version of CUDA from our support matrix](https://pytorch.org/get-started/locally/), then install the following:\n- [NVIDIA CUDA](https://developer.nvidia.com/cuda-downloads)\n- [NVIDIA cuDNN](https://developer.nvidia.com/cudnn) v9.0 or above\n- [Compiler](https://gist.github.com/ax3l/9489132) compatible with CUDA\n\nNote: You could refer to the [cuDNN Support Matrix](https://docs.nvidia.com/deeplearning/cudnn/backend/latest/reference/support-matrix.html) for cuDNN versions with the various supported CUDA, CUDA driver, and NVIDIA hardware.\n\nIf you want to disable CUDA support, export the environment variable `USE_CUDA=0`.\nOther potentially useful environment variables may be found in `setup.py`. If\nCUDA is installed in a non-standard location, set PATH so that the nvcc you\nwant to use can be found (e.g., `export PATH=/usr/local/cuda-12.8/bin:$PATH`).\n\nIf you are building for NVIDIA's Jetson platforms (Jetson Nano, TX1, TX2, AGX Xavier), Instructions to install PyTorch for Jetson Nano are [available here](https://devtalk.nvidia.com/default/topic/1049071/jetson-nano/pytorch-for-jetson-nano/)\n\n##### AMD ROCm Support\nIf you want to compile with ROCm support, install\n- [AMD ROCm](https://rocm.docs.amd.com/en/latest/deploy/linux/quick_start.html) 4.0 and above installation\n- ROCm is currently supported only for Linux systems.\n\nBy default the build system expects ROCm to be installed in `/opt/rocm`. If ROCm is installed in a different directory, the `ROCM_PATH` environment variable must be set to the ROCm installation directory. The build system automatically detects the AMD GPU architecture. Optionally, the AMD GPU architecture can be explicitly set with the `PYTORCH_ROCM_ARCH` environment variable [AMD GPU architecture](https://rocm.docs.amd.com/projects/install-on-linux/en/latest/reference/system-requirements.html#supported-gpus)\n\nIf you want to disable ROCm support, export the environment variable `USE_ROCM=0`.\nOther potentially useful environment variables may be found in `setup.py`.\n\n##### Intel GPU Support\nIf you want to compile with Intel GPU support, follow these\n- [PyTorch Prerequisites for Intel GPUs](https://www.intel.com/content/www/us/en/developer/articles/tool/pytorch-prerequisites-for-intel-gpu.html) instructions.\n- Intel GPU is supported for Linux and Windows.\n\nIf you want to disable Intel GPU support, export the environment variable `USE_XPU=0`.\nOther potentially useful environment variables may be found in `setup.py`.\n\n#### Get the PyTorch Source\n\n#### Install Dependencies\n\n**Common**\n\n**On Linux**\n\n**On Windows**\n\n#### Install PyTorch\n\n**On Linux**\n\nIf you're compiling for AMD ROCm then first run this command:\n\nInstall PyTorch\n\n**On macOS**\n\n**On Windows**\n\nIf you want to build legacy python code, please refer to [Building on legacy code and CUDA](https://github.com/pytorch/pytorch/blob/main/CONTRIBUTING.md#building-on-legacy-code-and-cud\n"
}
],
"json_schema": {
"title": "repo_knowledge_extraction",
"type": "object",
"additionalProperties": false,
"required": [
"repo_name",
"repo_url",
"repo_category",
"summary",
"learning_value",
"prerequisites",
"knowledge_points",
"suggested_learning_path",
"relevant_directories",
"tags"
],
"properties": {
"repo_name": {
"type": "string"
},
"repo_url": {
"type": "string"
},
"repo_category": {
"type": "string"
},
"summary": {
"type": "string"
},
"learning_value": {
"type": "string"
},
"prerequisites": {
"type": "array",
"items": {
"type": "string"
}
},
"knowledge_points": {
"type": "array",
"items": {
"type": "object",
"additionalProperties": false,
"required": [
"name",
"category",
"description",
"importance",
"evidence"
],
"properties": {
"name": {
"type": "string"
},
"category": {
"type": "string"
},
"description": {
"type": "string"
},
"importance": {
"type": "string"
},
"evidence": {
"type": "string"
}
}
}
},
"suggested_learning_path": {
"type": "array",
"items": {
"type": "string"
}
},
"relevant_directories": {
"type": "array",
"items": {
"type": "string"
}
},
"tags": {
"type": "array",
"items": {
"type": "string"
}
}
}
}
}
\ No newline at end of file
{
"repo_name": "llama_index",
"repo_url": "https://github.com/run-llama/llama_index",
"messages": [
{
"role": "system",
"content": "你是一个负责分析 GitHub 开源仓库的技术研究助手。你的任务是从 README、目录结构和仓库元信息中,提取适合后续培训、知识整理和项目分析使用的结构化知识点。输出必须严格符合给定 JSON Schema,不要输出额外解释,不要输出 Markdown。如果某个信息不能完全确定,可以基于 README 和目录结构做保守推断,但不要编造与仓库内容明显不符的信息。"
},
{
"role": "user",
"content": "请基于下面的 GitHub 仓库信息,提取结构化知识点。\n\n目标要求:\n1. 判断仓库类别,例如深度学习框架、Web 框架、LLM 应用框架、开发工具、数据平台等。\n2. 总结仓库的核心定位和学习价值。\n3. 提炼 5 到 8 个值得学习的知识点,每个知识点都要附带来源证据。\n4. 给出建议的前置知识和学习路径。\n5. 标出最值得关注的目录。\n\n仓库名称:llama_index\n仓库链接:https://github.com/run-llama/llama_index\n主要语言:Python\nStars:50809\n最近更新时间:2026-07-13T07:49:18Z\nmain_features:[\"🚀 Overview\", \"💡 Contributing\", \"📄 Documentation\", \"💻 Example Usage\", \"A note on Verification of Build Assets\", \"📖 Citation\"]\nmetadata:{\"owner\": \"run-llama\", \"default_branch\": \"main\", \"topics\": [\"agents\", \"application\", \"data\", \"fine-tuning\", \"framework\", \"llamaindex\", \"llm\", \"multi-agents\", \"rag\", \"vector-database\"]}\n\n目录结构摘录:\n├── .github\n│ ├── ISSUE_TEMPLATE\n│ │ ├── config.yml\n│ │ ├── docs-form.yml\n│ │ ├── feature-form.yml\n│ │ ├── issue-form.yml\n│ │ └── question-form.yml\n│ ├── workflows\n│ │ ├── build_package.yml\n│ │ ├── close_new_integration_prs.yml\n│ │ ├── codeql.yml\n│ │ ├── core-typecheck.yml\n│ │ ├── coverage_check.yml\n│ │ ├── issue_classifier.yml\n│ │ ├── lint.yml\n│ │ ├── llama_dev_tests.yml\n│ │ ├── pre_release.yml\n│ │ ├── publish_sub_package.yml\n│ │ ├── release.yml\n│ │ ├── stale_bot.yml\n│ │ ├── sync-docs.yml\n│ │ └── unit_test.yml\n│ ├── dependabot.yml\n│ └── pull_request_template.md\n├── docs\n│ ├── api_reference\n│ │ ├── api_reference\n│ │ │ ├── _static\n│ │ │ │ └── assets\n│ │ │ │ ├── LlamaLogoBrowserTab.png\n│ │ │ │ └── LlamaSquareBlack.svg\n│ │ │ ├── agent\n│ │ │ │ └── index.md\n│ │ │ ├── callbacks\n│ │ │ │ ├── agentops.md\n│ │ │ │ ├── aim.md\n│ │ │ │ ├── argilla.md\n│ │ │ │ ├── arize_phoenix.md\n│ │ │ │ ├── honeyhive.md\n│ │ │ │ ├── index.md\n│ │ │ │ ├── langfuse.md\n│ │ │ │ ├── literalai.md\n│ │ │ │ ├── llama_debug.md\n│ │ │ │ ├── openinference.md\n│ │ │ │ ├── opik.md\n│ │ │ │ ├── promptlayer.md\n│ │ │ │ ├── token_counter.md\n│ │ │ │ ├── uptrain.md\n│ │ │ │ └── wandb.md\n│ │ │ ├── chat_engines\n│ │ │ │ ├── condense_plus_context.md\n│ │ │ │ ├── condense_question.md\n│ │ │ │ ├── context.md\n│ │ │ │ ├── index.md\n│ │ │ │ └── simple.md\n│ │ │ ├── embeddings\n│ │ │ │ ├── adapter.md\n│ │ │ │ ├── alephalpha.md\n│ │ │ │ ├── alibabacloud_aisearch.md\n│ │ │ │ ├── anyscale.md\n│ │ │ │ ├── autoembeddings.md\n│ │ │ │ ├── azure_inference.md\n│ │ │ │ ├── azure_openai.md\n│ │ │ │ ├── baseten.md\n│ │ │ │ ├── bedrock.md\n│ │ │ │ ├── clarifai.md\n│ │ │ │ ├── clip.md\n│ │ │ │ ├── cloudflare_workersai.md\n│ │ │ │ ├── cohere.md\n│ │ │ │ ├── dashscope.md\n│ │ │ │ ├── databricks.md\n│ │ │ │ ├── deepinfra.md\n│ │ │ │ ├── elasticsearch.md\n│ │ │ │ ├── fastembed.md\n│ │ │ │ ├── fireworks.md\n│ │ │ │ ├── gaudi.md\n│ │ │ │ ├── gigachat.md\n│ │ │ │ ├── google_genai.md\n│ │ │ │ ├── heroku.md\n│ │ │ │ ├── huggingface.md\n│ │ │ │ ├── huggingface_api.md\n│ │ │ │ ├── huggingface_openvino.md\n│ │ │ │ ├── huggingface_optimum.md\n│ │ │ │ ├── huggingface_optimum_intel.md\n│ │ │ │ ├── ibm.md\n│ │ │ │ ├── index.md\n│ │ │ │ ├── instructor.md\n│ │ │ │ ├── ipex_llm.md\n│ │ │ │ ├── isaacus.md\n│ │ │ │ ├── jinaai.md\n│ │ │ │ ├── langchain.md\n│ │ │ │ ├── litellm.md\n│ │ │ │ ├── llamafile.md\n│ │ │ │ ├── llm_rails.md\n│ │ │ │ ├── mistralai.md\n│ │ │ │ ├── mixedbreadai.md\n│ │ │ │ ├── modelscope.md\n│ │ │ │ ├── nebius.md\n│ │ │ │ ├── netmind.md\n│ │ │ │ ├── nomic.md\n│ │ │ │ ├── nvidia.md\n│ │ │ │ ├── oci_data_science.md\n│ │ │ │ ├── oci_genai.md\n│ │ │ │ ├── ollama.md\n│ │ │ │ ├── opea.md\n│ │ │ │ ├── openai.md\n│ │ │ │ ├── openai_like.md\n│ │ │ │ ├── openvino_genai.md\n│ │ │ │ ├── oracleai.md\n│ │ │ │ ├── premai.md\n│ │ │ │ ├── sagemaker_endpoint.md\n│ │ │ │ ├── siliconflow.md\n│ │ │ │ ├── text_embeddings_inference.md\n│ │ │ │ ├── textembed.md\n│ │ │ │ ├── together.md\n│ │ │ │ ├── upstage.md\n│ │ │ │ ├── vertex.md\n│ │ │ │ ├── vertex_endpoint.md\n│ │ │ │ ├── vllm.md\n│ │ │ │ ├── voyageai.md\n\nREADME 摘录:\n# 🗂️ LlamaIndex 🦙\n\n[](https://pypi.org/project/llama-index/)\n[](https://github.com/run-llama/llama_index/actions/workflows/build_package.yml)\n[](https://github.com/jerryjliu/llama_index/graphs/contributors)\n[](https://discord.gg/dGcwcsnxhU)\n[](https://x.com/llama_index)\n[](https://www.reddit.com/r/LlamaIndex/)\n[](https://www.phorm.ai/query?projectId=c5863b56-6703-4a5d-87b6-7e6031bf16b6)\n\nLlamaIndex OSS (by [LlamaIndex](https://llamaindex.ai?utm_medium=li_github&utm_source=github&utm_campaign=2026--)) is an open-source framework to build agentic applications. **[Parse](https://cloud.llamaindex.ai?utm_medium=li_github&utm_source=github&utm_campaign=2026--)** is our enterprise platform for agentic OCR, parsing, extraction, indexing and more. You can use LlamaParse with this framework or on its own; see [LlamaParse](#llamacloud-document-agent-platform) below for signup and product links.\n\n> ### 📚 **Documentation:**\n>\n> - [LlamaParse](https://developers.llamaindex.ai/python/cloud/llamaparse/?utm_medium=li_github&utm_source=github&utm_campaign=2026--)\n> - [LlamaIndex OSS](https://developers.llamaindex.ai/python/framework/?utm_medium=li_github&utm_source=github&utm_campaign=2026--)\n> - [LlamaAgents](https://developers.llamaindex.ai/python/llamaagents/overview/?utm_medium=li_github&utm_source=github&utm_campaign=2026--)\n\nBuilding with LlamaIndex typically involves working with LlamaIndex core and a chosen set of integrations (or plugins). There are two ways to start building with LlamaIndex in\nPython:\n\n1. **Starter**: [`llama-index`](https://pypi.org/project/llama-index/). A starter Python package that includes core LlamaIndex as well as a selection of integrations.\n\n2. **Customized**: [`llama-index-core`](https://pypi.org/project/llama-index-core/). Install core LlamaIndex and add your chosen LlamaIndex integration packages on [LlamaHub](https://llamahub.ai/)\n that are required for your application. There are over 300 LlamaIndex integration\n packages that work seamlessly with core, allowing you to build with your preferred\n LLM, embedding, and vector store providers.\n\nThe LlamaIndex Python library is namespaced such that import statements which\ninclude `core` imply that the core package is being used. In contrast, those\nstatements without `core` imply that an integration package is being used.\n\n### LlamaParse (document agent platform)\n\n**LlamaParse** is its own platform—focused on document agents and agentic OCR. It includes **Parse** (parsing), **LlamaAgents** (deployed document agents), **Extract** (structured extraction), and **Index** (ingest and RAG). You can use it with the LlamaIndex framework or standalone.\n\n- **[Sign up for LlamaParse](https://cloud.llamaindex.ai?utm_medium=li_github&utm_source=github&utm_campaign=2026--)** — Create an account and get your API key.\n- **Parse** — Agentic OCR and document parsing (130+ formats). [Docs](https://developers.llamaindex.ai/python/cloud/llamaparse/?utm_medium=li_github&utm_source=github&utm_campaign=2026--)\n- **Extract** — Structured data extraction from documents. [Docs](https://developers.llamaindex.ai/python/cloud/llamaextract/?utm_medium=li_github&utm_source=github&utm_campaign=2026--)\n- **Index** — Ingest, index, and RAG pipelines. [Docs](https://developers.llamaindex.ai/python/cloud/llamacloud/?utm_medium=li_github&utm_source=github&utm_campaign=2026--)\n- **Split** — Split large documents into subcategories. [Docs](https://developers.llamaindex.ai/python/cloud/split/getting_started/?utm_medium=li_github&utm_source=github&utm_campaign=2026--)\n- **Agents** — Build end-to-end document agents with `Workflows` and Agent Builder. [Docs](https://developers.llamaindex.ai/python/llamaagents/overview/?utm_medium=li_github&utm_source=github&utm_campaign=2026--)\n\n### Important Links\n\n[Documentation](https://developers.llamaindex.ai/python/framework/?utm_medium=li_github&utm_source=github&utm_campaign=2026--)\n\n[X (formerly Twitter)](https://x.com/llama_index)\n\n[LinkedIn](https://www.linkedin.com/company/llamaindex/)\n\n[Reddit](https://www.reddit.com/r/LlamaIndex/)\n\n[Discord](https://discord.gg/dGcwcsnxhU)\n\n## 🚀 Overview\n\n**NOTE**: This README is not updated as frequently as the documentation. Please check out the documentation above for the latest updates!\n\n### Context\n\n- LLMs are a phenomenal piece of technology for knowledge generation and reasoning. They are pre-trained on large amounts of publicly available data.\n- How do we best augment LLMs with our own private data?\n\nWe need a comprehensive toolkit to help perform this data augmentation for LLMs.\n\n### Proposed Solution\n\nThat's where **LlamaIndex** comes in. LlamaIndex is a \"data framework\" to help you build LLM apps. It provides the following tools:\n\n- Offers **data connectors** to ingest your existing data sources and data formats (APIs, PDFs, docs, SQL, etc.).\n- Provides ways to **structure your data** (indices, graphs) so that this data can be easily used with LLMs.\n- Provides an **advanced retrieval/query interface over your data**: Feed in any LLM input prompt, get back retrieved context and knowledge-augmented output.\n- Allows easy integrations with your outer application framework (e.g. with LangChain, Flask, Docker, ChatGPT, or anything else).\n\nLlamaIndex provides tools for both beginner users and advanced users. Our high-level API allows beginner users to use LlamaIndex to ingest and query their data in\n5 lines of code. Our lower-level APIs allow advanced users to customize and extend any module (data connectors, indices, retrievers, query engines, reranking modules),\nto fit their needs.\n\n## 💡 Contributing\n\nInterested in contributing? Contributions to LlamaIndex core as well as contributing\nintegrations that build on the core are both accepted and highly encouraged! See our [Contribution Guide](CONTRIBUTING.md) for more details.\n\nNew integrations should meaningfully integrate with existing LlamaIndex framework components. At the discretion of LlamaIndex maintainers, some integrations may be declined.\n\n## 📄 Documentation\n\nFull documentation can be found [here](https://developers.llamaindex.ai/python/framework/?utm_medium=li_github&utm_source=github&utm_campaign=2026--)\n\nPlease check it out for the most up-to-date tutorials, how-to guides, references, and other resources!\n\n## 💻 Example Usage\n\nExamples are in the `docs/examples` folder. Indices are in the `indices` folder (see list of indices below).\n\nTo build a simple vector store index using OpenAI:\n\nTo build a simple vector store index using non-OpenAI LLMs, e.g. LLMs hosted through Ollama:\n\nTo query:\n\nBy default, data is stored in-memory.\nTo persist to disk (under `./storage`):\n\nTo reload from disk:\n\n## A note on Verification of Build Assets\n\nBy default, `llama-index-core` includes a `_static` folder that contains the nltk and tiktoken cache that is included with the package installation. This ensures that you can easily run `llama-index` in environments with restrictive disk access permissions at runtime.\n\nTo verify that these files are safe and valid, we use the github `attest-build-provenance` action. This action will verify that the files in the `_static` folder are the same as the files in the `llama-index-core/llama_index/core/_static` folder.\n\nTo verify this, you can run the following script (pointing to your installed package):\n\n## 📖 Citation\n\nReference to cite if you use LlamaIndex in a paper:\n"
}
],
"json_schema": {
"title": "repo_knowledge_extraction",
"type": "object",
"additionalProperties": false,
"required": [
"repo_name",
"repo_url",
"repo_category",
"summary",
"learning_value",
"prerequisites",
"knowledge_points",
"suggested_learning_path",
"relevant_directories",
"tags"
],
"properties": {
"repo_name": {
"type": "string"
},
"repo_url": {
"type": "string"
},
"repo_category": {
"type": "string"
},
"summary": {
"type": "string"
},
"learning_value": {
"type": "string"
},
"prerequisites": {
"type": "array",
"items": {
"type": "string"
}
},
"knowledge_points": {
"type": "array",
"items": {
"type": "object",
"additionalProperties": false,
"required": [
"name",
"category",
"description",
"importance",
"evidence"
],
"properties": {
"name": {
"type": "string"
},
"category": {
"type": "string"
},
"description": {
"type": "string"
},
"importance": {
"type": "string"
},
"evidence": {
"type": "string"
}
}
}
},
"suggested_learning_path": {
"type": "array",
"items": {
"type": "string"
}
},
"relevant_directories": {
"type": "array",
"items": {
"type": "string"
}
},
"tags": {
"type": "array",
"items": {
"type": "string"
}
}
}
}
}
\ No newline at end of file
{
"repo_name": "scikit-learn",
"repo_url": "https://github.com/scikit-learn/scikit-learn",
"messages": [
{
"role": "system",
"content": "你是一个负责分析 GitHub 开源仓库的技术研究助手。你的任务是从 README、目录结构和仓库元信息中,提取适合后续培训、知识整理和项目分析使用的结构化知识点。输出必须严格符合给定 JSON Schema,不要输出额外解释,不要输出 Markdown。如果某个信息不能完全确定,可以基于 README 和目录结构做保守推断,但不要编造与仓库内容明显不符的信息。"
},
{
"role": "user",
"content": "请基于下面的 GitHub 仓库信息,提取结构化知识点。\n\n目标要求:\n1. 判断仓库类别,例如深度学习框架、Web 框架、LLM 应用框架、开发工具、数据平台等。\n2. 总结仓库的核心定位和学习价值。\n3. 提炼 5 到 8 个值得学习的知识点,每个知识点都要附带来源证据。\n4. 给出建议的前置知识和学习路径。\n5. 标出最值得关注的目录。\n\n仓库名称:scikit-learn\n仓库链接:https://github.com/scikit-learn/scikit-learn\n主要语言:Python\nStars:66666\n最近更新时间:2026-07-13T06:53:03Z\nmain_features:[\"Data analysis\", \"Data science\", \"Machine learning\", \"Python\", \"Statistics\"]\nmetadata:{\"owner\": \"scikit-learn\", \"default_branch\": \"main\", \"topics\": [\"data-analysis\", \"data-science\", \"machine-learning\", \"python\", \"statistics\"]}\n\n目录结构摘录:\n├── .binder\n│ ├── postBuild\n│ ├── requirements.txt\n│ └── runtime.txt\n├── .circleci\n│ └── config.yml\n├── .devcontainer\n│ ├── devcontainer.json\n│ └── setup.sh\n├── .github\n│ ├── ISSUE_TEMPLATE\n│ │ ├── bug_report.yml\n│ │ ├── config.yml\n│ │ ├── doc_improvement.yml\n│ │ └── feature_request.yml\n│ ├── scripts\n│ │ ├── add_or_remove_no_pr_warning.py\n│ │ └── label_title_regex.py\n│ ├── workflows\n│ │ ├── artifact-redirector.yml\n│ │ ├── autoclose-comment.yml\n│ │ ├── autoclose-schedule.yml\n│ │ ├── bot-lint-comment.yml\n│ │ ├── check-changelog.yml\n│ │ ├── check-sdist.yml\n│ │ ├── codeql.yml\n│ │ ├── codespell.yml\n│ │ ├── cuda-ci.yml\n│ │ ├── cuda-label-remover.yml\n│ │ ├── emscripten.yml\n│ │ ├── label-blank-issue.yml\n│ │ ├── labeler-module.yml\n│ │ ├── labeler-title-regex.yml\n│ │ ├── lint.yml\n│ │ ├── needs-decision.yml\n│ │ ├── not-ready-for-pr-warning.yml\n│ │ ├── publish_pypi.yml\n│ │ ├── unit-tests.yml\n│ │ ├── update-lock-files.yml\n│ │ ├── update_tracking_issue.yml\n│ │ ├── welcome-first-time-contributor.yml\n│ │ └── wheels.yml\n│ ├── dependabot.yml\n│ ├── FUNDING.yml\n│ ├── labeler-file-extensions.yml\n│ ├── labeler-module.yml\n│ └── PULL_REQUEST_TEMPLATE.md\n├── .spin\n│ └── cmds.py\n├── asv_benchmarks\n│ ├── benchmarks\n│ │ ├── __init__.py\n│ │ ├── cluster.py\n│ │ ├── common.py\n│ │ ├── config.json\n│ │ ├── datasets.py\n│ │ ├── decomposition.py\n│ │ ├── ensemble.py\n│ │ ├── linear_model.py\n│ │ ├── manifold.py\n│ │ ├── metrics.py\n│ │ ├── model_selection.py\n│ │ ├── neighbors.py\n│ │ ├── svm.py\n│ │ └── utils.py\n│ ├── .gitignore\n│ └── asv.conf.json\n├── benchmarks\n│ ├── .gitignore\n│ ├── bench_20newsgroups.py\n│ ├── bench_covertype.py\n│ ├── bench_feature_expansions.py\n│ ├── bench_glm.py\n│ ├── bench_glmnet.py\n│ ├── bench_hist_gradient_boosting.py\n│ ├── bench_hist_gradient_boosting_adult.py\n│ ├── bench_hist_gradient_boosting_categorical_only.py\n│ ├── bench_hist_gradient_boosting_higgsboson.py\n│ ├── bench_hist_gradient_boosting_threading.py\n│ ├── bench_isolation_forest.py\n│ ├── bench_isolation_forest_predict.py\n│ ├── bench_isotonic.py\n│ ├── bench_kernel_pca_solvers_time_vs_n_components.py\n│ ├── bench_kernel_pca_solvers_time_vs_n_samples.py\n│ ├── bench_lasso.py\n│ ├── bench_lof.py\n│ ├── bench_mnist.py\n│ ├── bench_online_ocsvm.py\n│ ├── bench_pca_solvers.py\n│ ├── bench_plot_fastkmeans.py\n│ ├── bench_plot_hierarchical.py\n│ ├── bench_plot_incremental_pca.py\n│ ├── bench_plot_lasso_path.py\n│ ├── bench_plot_neighbors.py\n│ ├── bench_plot_nmf.py\n│ ├── bench_plot_omp_lars.py\n│ ├── bench_plot_parallel_pairwise.py\n│ ├── bench_plot_polynomial_kernel_approximation.py\n│ ├── bench_plot_randomized_svd.py\n│ ├── bench_plot_svd.py\n│ ├── bench_plot_ward.py\n│ ├── bench_random_projections.py\n│ ├── bench_rcv1_logreg_convergence.py\n│ ├── bench_saga.py\n│ ├── bench_sample_without_replacement.py\n│ ├── bench_sgd_regression.py\n│ ├── bench_sparsify.py\n│ ├── bench_text_vectorizers.py\n│ ├── bench_tree.py\n│ ├── bench_tsne_mnist.py\n│ └── plot_tsne_mnist.py\n├── build_tools\n│ ├── circle\n│ │ ├── build_doc.sh\n│ │ ├── checkout_merge_commit.sh\n│ │ ├── doc_environment.yml\n│ │ ├── doc_linux-64_conda.lock\n│ │ ├── doc_min_dependencies_environment.yml\n│ │ ├── doc_min_dependencies_linux-64_conda.lock\n│ │ ├── download_documentation.sh\n\nREADME 摘录:\n.. -*- mode: rst -*-\n\n|GitHubActions| |Codecov| |CircleCI| |Nightly wheels| |Ruff| |PythonVersion| |PyPI| |DOI| |Benchmark|\n\n.. |GitHubActions| image:: https://github.com/scikit-learn/scikit-learn/actions/workflows/unit-tests.yml/badge.svg?\n :target: https://github.com/scikit-learn/scikit-learn/actions/workflows/unit-tests.yml?query=branch%3Amain\n\n.. |CircleCI| image:: https://circleci.com/gh/scikit-learn/scikit-learn/tree/main.svg?style=shield\n :target: https://circleci.com/gh/scikit-learn/scikit-learn\n\n.. |Codecov| image:: https://codecov.io/gh/scikit-learn/scikit-learn/branch/main/graph/badge.svg?token=Pk8G9gg3y9\n :target: https://codecov.io/gh/scikit-learn/scikit-learn\n\n.. |Nightly wheels| image:: https://github.com/scikit-learn/scikit-learn/actions/workflows/wheels.yml/badge.svg?event=schedule\n :target: https://github.com/scikit-learn/scikit-learn/actions?query=workflow%3A%22Wheel+builder%22+event%3Aschedule\n\n.. |Ruff| image:: https://img.shields.io/badge/code%20style-ruff-000000.svg?\n :target: https://github.com/astral-sh/ruff\n\n.. |PythonVersion| image:: https://img.shields.io/pypi/pyversions/scikit-learn.svg?\n :target: https://pypi.org/project/scikit-learn/\n\n.. |PyPI| image:: https://img.shields.io/pypi/v/scikit-learn\n :target: https://pypi.org/project/scikit-learn\n\n.. |DOI| image:: https://zenodo.org/badge/DOI/10.5281/zenodo.17880109.svg?\n :target: https://zenodo.org/badge/latestdoi/21369/scikit-learn/scikit-learn\n\n.. |Benchmark| image:: https://img.shields.io/badge/Benchmarked%20by-asv-blue\n :target: https://scikit-learn.org/scikit-learn-benchmarks\n\n.. |PythonMinVersion| replace:: 3.11\n.. |NumPyMinVersion| replace:: 1.24.1\n.. |SciPyMinVersion| replace:: 1.10.0\n.. |JoblibMinVersion| replace:: 1.4.0\n.. |NarwhalsMinVersion| replace:: 2.0.1\n.. |ThreadpoolctlMinVersion| replace:: 3.5.0\n.. |MatplotlibMinVersion| replace:: 3.6.1\n.. |Scikit-ImageMinVersion| replace:: 0.22.0\n.. |PandasMinVersion| replace:: 1.5.0\n.. |SeabornMinVersion| replace:: 0.13.0\n.. |PytestMinVersion| replace:: 7.1.2\n.. |PlotlyMinVersion| replace:: 5.22.0\n\n.. image:: https://raw.githubusercontent.com/scikit-learn/scikit-learn/main/doc/logos/scikit-learn-logo.png\n :target: https://scikit-learn.org/\n\n**scikit-learn** is a Python module for machine learning built on top of\nSciPy and is distributed under the 3-Clause BSD license.\n\nThe project was started in 2007 by David Cournapeau as a Google Summer\nof Code project, and since then many volunteers have contributed. See\nthe `About us <https://scikit-learn.org/dev/about.html#authors>`__ page\nfor a list of core contributors.\n\nIt is currently maintained by a team of volunteers.\n\nWebsite: https://scikit-learn.org\n\nInstallation\n------------\n\nDependencies\n~~~~~~~~~~~~\n\nscikit-learn requires:\n\n- Python (>= |PythonMinVersion|)\n- NumPy (>= |NumPyMinVersion|)\n- SciPy (>= |SciPyMinVersion|)\n- Narwhals (>= |NarwhalsMinVersion|)\n- joblib (>= |JoblibMinVersion|)\n- threadpoolctl (>= |ThreadpoolctlMinVersion|)\n\n=======\n\nScikit-learn plotting capabilities (i.e., functions start with ``plot_`` and\nclasses end with ``Display``) require Matplotlib (>= |MatplotlibMinVersion|).\nFor running the examples Matplotlib >= |MatplotlibMinVersion| is required.\nA few examples require scikit-image >= |Scikit-ImageMinVersion|, a few examples\nrequire pandas >= |PandasMinVersion|, some examples require seaborn >=\n|SeabornMinVersion| and Plotly >= |PlotlyMinVersion|.\n\nUser installation\n~~~~~~~~~~~~~~~~~\n\nIf you already have a working installation of NumPy and SciPy,\nthe easiest way to install scikit-learn is using ``pip``::\n\n pip install -U scikit-learn\n\nor ``conda``::\n\n conda install -c conda-forge scikit-learn\n\nThe documentation includes more detailed `installation instructions <https://scikit-learn.org/stable/install.html>`_.\n\nChangelog\n---------\n\nSee the `changelog <https://scikit-learn.org/dev/whats_new.html>`__\nfor a history of notable changes to scikit-learn.\n\nDevelopment\n-----------\n\nWe welcome new contributors of all experience levels. The scikit-learn\ncommunity goals are to be helpful, welcoming, and effective. The\n`Development Guide <https://scikit-learn.org/stable/developers/index.html>`_\nhas detailed information about contributing code, documentation, tests, and\nmore. We've included some basic information in this README.\n\nImportant links\n~~~~~~~~~~~~~~~\n\n- Official source code repo: https://github.com/scikit-learn/scikit-learn\n- Download releases: https://pypi.org/project/scikit-learn/\n- Issue tracker: https://github.com/scikit-learn/scikit-learn/issues\n\nSource code\n~~~~~~~~~~~\n\nYou can check the latest sources with the command::\n\n git clone https://github.com/scikit-learn/scikit-learn.git\n\nContributing\n~~~~~~~~~~~~\n\nTo learn more about making a contribution to scikit-learn, please see our\n`Contributing guide\n<https://scikit-learn.org/dev/developers/contributing.html>`_.\n\nTesting\n~~~~~~~\n\nAfter installation, you can launch the test suite from outside the source\ndirectory (you will need to have ``pytest`` >= |PytestMinVersion| installed)::\n\n pytest sklearn\n\nSee the web page https://scikit-learn.org/dev/developers/contributing.html#testing-and-improving-test-coverage\nfor more information.\n\n Random number generation can be controlled during testing by setting\n the ``SKLEARN_SEED`` environment variable.\n\nSubmitting a Pull Request\n~~~~~~~~~~~~~~~~~~~~~~~~~\n\nBefore opening a Pull Request, have a look at the\nfull Contributing page to make sure your code complies\nwith our guidelines: https://scikit-learn.org/stable/developers/index.html\n\nProject History\n---------------\n\nThe project was started in 2007 by David Cournapeau as a Google Summer\nof Code project, and since then many volunteers have contributed. See\nthe `About us <https://scikit-learn.org/dev/about.html#authors>`__ page\nfor a list of core contributors.\n\nThe project is currently maintained by a team of volunteers.\n\n**Note**: `scikit-learn` was previously referred to as `scikits.learn`.\n\nHelp and Support\n----------------\n\nDocumentation\n~~~~~~~~~~~~~\n\n- HTML documentation (stable release): https://scikit-learn.org\n- HTML documentation (development version): https://scikit-learn.org/dev/\n- FAQ: https://scikit-learn.org/stable/faq.html\n\nCommunication\n~~~~~~~~~~~~~\n\nMain Channels\n^^^^^^^^^^^^^\n\n- **Website**: https://scikit-learn.org\n- **Blog**: https://blog.scikit-learn.org\n- **Mailing list**: https://mail.python.org/mailman/listinfo/scikit-learn\n\nDeveloper & Support\n^^^^^^^^^^^^^^^^^^^^^^\n\n- **GitHub Discussions**: https://github.com/scikit-learn/scikit-learn/discussions\n- **Stack Overflow**: https://stackoverflow.com/questions/tagged/scikit-learn\n- **Discord**: https://discord.gg/h9qyrK8Jc8\n\nSocial Media Platforms\n^^^^^^^^^^^^^^^^^^^^^^\n\n- **LinkedIn**: https://www.linkedin.com/company/scikit-learn\n- **YouTube**: https://www.youtube.com/channel/UCJosFjYm0ZYVUARxuOZqnnw/playlists\n- **Facebook**: https://www.facebook.com/scikitlearnofficial/\n- **Instagram**: https://www.instagram.com/scikitlearnofficial/\n- **TikTok**: https://www.tiktok.com/@scikit.learn\n- **Bluesky**: https://bsky.app/profile/scikit-learn.org\n- **Mastodon**: https://mastodon.social/@sklearn@fosstodon.org\n\nResources\n^^^^^^^^^\n\n- **Calendar**: https://blog.scikit-learn.org/calendar/\n- **Logos & Branding**: https://github.com/scikit-learn/scikit-learn/tree/main/doc/logos\n\nCitation\n~~~~~~~~\n\nIf you use scikit-learn in a scientific publication, we would appreciate citations: https://scikit-learn.org/stable/about.html#citing-scikit-learn\n"
}
],
"json_schema": {
"title": "repo_knowledge_extraction",
"type": "object",
"additionalProperties": false,
"required": [
"repo_name",
"repo_url",
"repo_category",
"summary",
"learning_value",
"prerequisites",
"knowledge_points",
"suggested_learning_path",
"relevant_directories",
"tags"
],
"properties": {
"repo_name": {
"type": "string"
},
"repo_url": {
"type": "string"
},
"repo_category": {
"type": "string"
},
"summary": {
"type": "string"
},
"learning_value": {
"type": "string"
},
"prerequisites": {
"type": "array",
"items": {
"type": "string"
}
},
"knowledge_points": {
"type": "array",
"items": {
"type": "object",
"additionalProperties": false,
"required": [
"name",
"category",
"description",
"importance",
"evidence"
],
"properties": {
"name": {
"type": "string"
},
"category": {
"type": "string"
},
"description": {
"type": "string"
},
"importance": {
"type": "string"
},
"evidence": {
"type": "string"
}
}
}
},
"suggested_learning_path": {
"type": "array",
"items": {
"type": "string"
}
},
"relevant_directories": {
"type": "array",
"items": {
"type": "string"
}
},
"tags": {
"type": "array",
"items": {
"type": "string"
}
}
}
}
}
\ No newline at end of file
{
"repo_name": "streamlit",
"repo_url": "https://github.com/streamlit/streamlit",
"messages": [
{
"role": "system",
"content": "你是一个负责分析 GitHub 开源仓库的技术研究助手。你的任务是从 README、目录结构和仓库元信息中,提取适合后续培训、知识整理和项目分析使用的结构化知识点。输出必须严格符合给定 JSON Schema,不要输出额外解释,不要输出 Markdown。如果某个信息不能完全确定,可以基于 README 和目录结构做保守推断,但不要编造与仓库内容明显不符的信息。"
},
{
"role": "user",
"content": "请基于下面的 GitHub 仓库信息,提取结构化知识点。\n\n目标要求:\n1. 判断仓库类别,例如深度学习框架、Web 框架、LLM 应用框架、开发工具、数据平台等。\n2. 总结仓库的核心定位和学习价值。\n3. 提炼 5 到 8 个值得学习的知识点,每个知识点都要附带来源证据。\n4. 给出建议的前置知识和学习路径。\n5. 标出最值得关注的目录。\n\n仓库名称:streamlit\n仓库链接:https://github.com/streamlit/streamlit\n主要语言:Python\nStars:45220\n最近更新时间:2026-07-13T07:43:05Z\nmain_features:[\"Simple and Pythonic: Write beautiful, easy-to-read code\", \"Fast, interactive prototyping: Let others interact with your data and provide feedback quickly\", \"Live editing: See your app update instantly as you edit your script\", \"Open-source and free: Join a vibrant community and contribute to Streamlit's future\"]\nmetadata:{\"owner\": \"streamlit\", \"default_branch\": \"develop\", \"topics\": [\"data-analysis\", \"data-science\", \"data-visualization\", \"deep-learning\", \"developer-tools\", \"machine-learning\", \"python\", \"streamlit\"]}\n\n目录结构摘录:\n├── .claude\n│ ├── agents\n│ │ ├── AGENTS.md\n│ │ ├── CLAUDE.md\n│ │ ├── fixing-pr.md\n│ │ ├── qa-testing-feature.md\n│ │ ├── reviewing-local-changes.md\n│ │ └── simplifying-local-changes.md\n│ ├── commands\n│ │ ├── fixing-pr.md\n│ │ ├── qa-testing-feature.md\n│ │ ├── reviewing-local-changes.md\n│ │ └── simplifying-local-changes.md\n│ ├── hooks\n│ │ ├── post_edit_autofix.sh\n│ │ ├── pre_bash_redirect.py\n│ │ └── stop_check.sh\n│ ├── skills\n│ │ ├── addressing-pr-review-comments\n│ │ │ └── SKILL.md\n│ │ ├── assessing-external-test-risk\n│ │ │ └── SKILL.md\n│ │ ├── checking-changes\n│ │ │ └── SKILL.md\n│ │ ├── creating-pull-requests\n│ │ │ └── SKILL.md\n│ │ ├── debugging-streamlit\n│ │ │ └── SKILL.md\n│ │ ├── discovering-make-commands\n│ │ │ └── SKILL.md\n│ │ ├── finalizing-pr\n│ │ │ └── SKILL.md\n│ │ ├── fixing-flaky-e2e-tests\n│ │ │ └── SKILL.md\n│ │ ├── fixing-streamlit-ci\n│ │ │ └── SKILL.md\n│ │ ├── generating-changelog\n│ │ │ └── SKILL.md\n│ │ ├── implementing-feature\n│ │ │ └── SKILL.md\n│ │ ├── improving-frontend-coverage\n│ │ │ └── SKILL.md\n│ │ ├── improving-python-coverage\n│ │ │ └── SKILL.md\n│ │ ├── sharing-pr-agent-artifacts\n│ │ │ └── SKILL.md\n│ │ ├── understanding-streamlit-architecture\n│ │ │ ├── references\n│ │ │ │ ├── backend.md\n│ │ │ │ ├── communication.md\n│ │ │ │ ├── element-identity.md\n│ │ │ │ ├── frontend.md\n│ │ │ │ └── layout.md\n│ │ │ └── SKILL.md\n│ │ ├── updating-internal-docs\n│ │ │ └── SKILL.md\n│ │ ├── writing-spec\n│ │ │ └── SKILL.md\n│ │ ├── AGENTS.md\n│ │ └── CLAUDE.md\n│ ├── .gitignore\n│ └── settings.json\n├── .codex\n│ ├── agents\n│ │ ├── fixing-pr.toml\n│ │ ├── qa-testing-feature.toml\n│ │ ├── reviewing-local-changes.toml\n│ │ └── simplifying-local-changes.toml\n│ ├── .gitignore\n│ ├── config.toml\n│ └── skills\n├── .cursor\n│ ├── rules\n│ │ ├── agents.mdc\n│ │ ├── e2e_playwright.mdc\n│ │ ├── overview.mdc\n│ │ ├── protobuf.mdc\n│ │ ├── python.mdc\n│ │ ├── python_lib.mdc\n│ │ ├── python_tests.mdc\n│ │ ├── scripts.mdc\n│ │ ├── skills.mdc\n│ │ ├── specs.mdc\n│ │ ├── typescript.mdc\n│ │ └── workflows.mdc\n│ ├── .gitignore\n│ ├── hooks.json\n│ └── worktrees.json\n├── .devcontainer\n│ ├── devcontainer.json\n│ └── Dockerfile\n├── .github\n│ ├── actions\n│ │ ├── apt_mirror_fix\n│ │ │ ├── action.yml\n│ │ │ └── apt_mirror_fix.sh\n│ │ ├── build_info\n│ │ │ └── action.yml\n│ │ ├── make_init\n│ │ │ └── action.yml\n│ │ ├── playwright_install\n│ │ │ └── action.yml\n│ │ └── preview_branch\n│ │ └── action.yml\n│ ├── instructions\n│ │ ├── agents.instructions.md\n│ │ ├── e2e_playwright.instructions.md\n│ │ ├── protobuf.instructions.md\n│ │ ├── python.instructions.md\n│ │ ├── python_lib.instructions.md\n│ │ ├── python_tests.instructions.md\n│ │ ├── scripts.instructions.md\n│ │ ├── skills.instructions.md\n│ │ ├── specs.instructions.md\n│ │ ├── typescript.instructions.md\n│ │ └── workflows.instructions.md\n│ ├── ISSUE_TEMPLATE\n│ │ ├── bug_report.yml\n│ │ ├── config.yml\n│ │ ├── feature_request.yml\n\nREADME 摘录:\n<br>\n\n</img>\n\n# Welcome to Streamlit 👋\n\n**A faster way to build and share data apps.**\n\n## What is Streamlit?\n\nStreamlit lets you transform Python scripts into interactive web apps in minutes, instead of weeks. Build dashboards, generate reports, or create chat apps. Once you’ve created an app, you can use our [Community Cloud platform](https://streamlit.io/cloud) to deploy, manage, and share your app.\n\n### Why choose Streamlit?\n\n- **Simple and Pythonic:** Write beautiful, easy-to-read code.\n- **Fast, interactive prototyping:** Let others interact with your data and provide feedback quickly.\n- **Live editing:** See your app update instantly as you edit your script.\n- **Open-source and free:** Join a vibrant community and contribute to Streamlit's future.\n\n## Installation\n\nOpen a terminal and run:\n\nIf this opens our sweet _Streamlit Hello_ app in your browser, you're all set! If not, head over to [our docs](https://docs.streamlit.io/get-started) for specific installs.\n\nThe app features a bunch of examples of what you can do with Streamlit. Jump to the [quickstart](#quickstart) section to understand how that all works.\n\n</img>\n\n## Quickstart\n\n### A little example\n\nCreate a new file named `streamlit_app.py` in your project directory with the following code:\n\nNow run it to open the app!\n\n</img>\n\n### Give me more!\n\nStreamlit comes in with [a ton of additional powerful elements](https://docs.streamlit.io/develop/api-reference) to spice up your data apps and delight your viewers. Some examples:\n\n<table border=\"0\">\n <tr>\n <td>\n <a target=\"_blank\" href=\"https://docs.streamlit.io/develop/api-reference/widgets\">\n \n </a>\n </td>\n <td>\n <a target=\"_blank\" href=\"https://docs.streamlit.io/develop/api-reference/data/st.dataframe\">\n \n </a>\n </td>\n <td>\n <a target=\"_blank\" href=\"https://docs.streamlit.io/develop/api-reference/charts\">\n \n </a>\n </td>\n <td>\n <a target=\"_blank\" href=\"https://docs.streamlit.io/develop/api-reference/layout\">\n \n </a>\n </td>\n <td>\n <a target=\"_blank\" href=\"https://docs.streamlit.io/develop/concepts/multipage-apps\">\n \n </a>\n </td>\n <td>\n <a target=\"_blank\" href=\"https://streamlit.io/gallery\">\n \n </a>\n </td>\n </tr>\n <tr>\n <td>Input widgets</td>\n <td>Dataframes</td>\n <td>Charts</td>\n <td>Layout</td>\n <td>Multi-page apps</td>\n <td>Fun</td>\n </tr>\n</table>\n\nOur vibrant creators community also extends Streamlit capabilities using  🧩 [Streamlit Components](https://streamlit.io/components).\n\n## Get inspired\n\nThere's so much you can build with Streamlit:\n- 🤖  [LLMs & chatbot apps](https://streamlit.io/gallery?category=llms)\n- 🧬  [Science & technology apps](https://streamlit.io/gallery?category=science-technology)\n- 💬  [NLP & language apps](https://streamlit.io/gallery?category=nlp-language)\n- 🏦  [Finance & business apps](https://streamlit.io/gallery?category=finance-business)\n- 🗺  [Geography & society apps](https://streamlit.io/gallery?category=geography-society)\n- and more!\n\n**Check out [our gallery!](https://streamlit.io/gallery)** 🎈\n\n## Community Cloud\n\nDeploy, manage and share your apps for free using our [Community Cloud](https://streamlit.io/cloud)! Sign-up [here](https://share.streamlit.io/signup). <br><br>\n</img>\n\n## Resources\n\n- Explore our [docs](https://docs.streamlit.io) to learn how Streamlit works.\n- Ask questions and get help in our [community forum](https://discuss.streamlit.io).\n- Read our [blog](https://blog.streamlit.io) for tips from developers and creators.\n- Extend Streamlit's capabilities by installing or creating your own [Streamlit Components](https://streamlit.io/components).\n- Help others find and play with your app by using the Streamlit GitHub badge in your repository:\n\n[](https://share.streamlit.io/streamlit/roadmap)\n\n## Contribute\n\n🎉 Thanks for your interest in helping improve Streamlit! 🎉\n\nBefore contributing, please read our guidelines here: https://github.com/streamlit/streamlit/blob/develop/CONTRIBUTING.md\n\n## License\n\nStreamlit is completely free and open-source and licensed under the [Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0) license.\n"
}
],
"json_schema": {
"title": "repo_knowledge_extraction",
"type": "object",
"additionalProperties": false,
"required": [
"repo_name",
"repo_url",
"repo_category",
"summary",
"learning_value",
"prerequisites",
"knowledge_points",
"suggested_learning_path",
"relevant_directories",
"tags"
],
"properties": {
"repo_name": {
"type": "string"
},
"repo_url": {
"type": "string"
},
"repo_category": {
"type": "string"
},
"summary": {
"type": "string"
},
"learning_value": {
"type": "string"
},
"prerequisites": {
"type": "array",
"items": {
"type": "string"
}
},
"knowledge_points": {
"type": "array",
"items": {
"type": "object",
"additionalProperties": false,
"required": [
"name",
"category",
"description",
"importance",
"evidence"
],
"properties": {
"name": {
"type": "string"
},
"category": {
"type": "string"
},
"description": {
"type": "string"
},
"importance": {
"type": "string"
},
"evidence": {
"type": "string"
}
}
}
},
"suggested_learning_path": {
"type": "array",
"items": {
"type": "string"
}
},
"relevant_directories": {
"type": "array",
"items": {
"type": "string"
}
},
"tags": {
"type": "array",
"items": {
"type": "string"
}
}
}
}
}
\ No newline at end of file
{
"repo_name": "vllm",
"repo_url": "https://github.com/vllm-project/vllm",
"messages": [
{
"role": "system",
"content": "你是一个负责分析 GitHub 开源仓库的技术研究助手。你的任务是从 README、目录结构和仓库元信息中,提取适合后续培训、知识整理和项目分析使用的结构化知识点。输出必须严格符合给定 JSON Schema,不要输出额外解释,不要输出 Markdown。如果某个信息不能完全确定,可以基于 README 和目录结构做保守推断,但不要编造与仓库内容明显不符的信息。"
},
{
"role": "user",
"content": "请基于下面的 GitHub 仓库信息,提取结构化知识点。\n\n目标要求:\n1. 判断仓库类别,例如深度学习框架、Web 框架、LLM 应用框架、开发工具、数据平台等。\n2. 总结仓库的核心定位和学习价值。\n3. 提炼 5 到 8 个值得学习的知识点,每个知识点都要附带来源证据。\n4. 给出建议的前置知识和学习路径。\n5. 标出最值得关注的目录。\n\n仓库名称:vllm\n仓库链接:https://github.com/vllm-project/vllm\n主要语言:Python\nStars:86109\n最近更新时间:2026-07-13T08:08:18Z\nmain_features:[\"About\", \"Citation\", \"Contact Us\", \"Media Kit\"]\nmetadata:{\"owner\": \"vllm-project\", \"default_branch\": \"main\", \"topics\": [\"amd\", \"blackwell\", \"cuda\", \"deepseek\", \"deepseek-v3\", \"gpt\", \"gpt-oss\", \"inference\", \"kimi\", \"llama\", \"llm\", \"llm-serving\", \"model-serving\", \"moe\", \"openai\", \"pytorch\", \"qwen\", \"qwen3\", \"tpu\", \"transformer\"]}\n\n目录结构摘录:\n├── .buildkite\n│ ├── hardware_tests\n│ │ ├── intel_xpu_ci\n│ │ │ └── test-intel.yaml\n│ │ ├── amd.yaml\n│ │ ├── ascend_npu.yaml\n│ │ ├── cpu.yaml\n│ │ ├── gh200.yaml\n│ │ └── intel.yaml\n│ ├── image_build\n│ │ ├── image_build.sh\n│ │ ├── image_build.yaml\n│ │ ├── image_build_arm64.sh\n│ │ ├── image_build_cpu.sh\n│ │ ├── image_build_cpu_arm64.sh\n│ │ ├── image_build_hpu.sh\n│ │ ├── image_build_torch_nightly.sh\n│ │ └── image_build_xpu.sh\n│ ├── intel_jobs\n│ │ ├── basic_correctness.yaml\n│ │ ├── engine_intel.yaml\n│ │ ├── expert_parallelism_intel.yaml\n│ │ ├── kernels_intel.yaml\n│ │ ├── lora_intel.yaml\n│ │ ├── misc_intel.yaml\n│ │ ├── model_runner_v2_intel.yaml\n│ │ ├── models_distributed_intel.yaml\n│ │ ├── models_multimodal_intel.yaml\n│ │ ├── quantization.yaml\n│ │ └── test-intel.yaml\n│ ├── lm-eval-harness\n│ │ ├── configs\n│ │ │ ├── DeepSeek-V2-Lite-Chat.yaml\n│ │ │ ├── Meta-Llama-3-70B-Instruct-FBGEMM-nonuniform.yaml\n│ │ │ ├── Meta-Llama-3-70B-Instruct.yaml\n│ │ │ ├── Meta-Llama-3-8B-Instruct-Channelwise-compressed-tensors.yaml\n│ │ │ ├── Meta-Llama-3-8B-Instruct-FBGEMM-nonuniform.yaml\n│ │ │ ├── Meta-Llama-3-8B-Instruct-FP8-compressed-tensors.yaml\n│ │ │ ├── Meta-Llama-3-8B-Instruct-FP8.yaml\n│ │ │ ├── Meta-Llama-3-8B-Instruct-INT8-compressed-tensors-asym.yaml\n│ │ │ ├── Meta-Llama-3-8B-Instruct-INT8-compressed-tensors.yaml\n│ │ │ ├── Meta-Llama-3-8B-Instruct-nonuniform-compressed-tensors.yaml\n│ │ │ ├── Meta-Llama-3-8B-Instruct.yaml\n│ │ │ ├── Meta-Llama-3-8B-QQQ.yaml\n│ │ │ ├── Meta-Llama-3.2-1B-Instruct-FP8-compressed-tensors.yaml\n│ │ │ ├── Meta-Llama-3.2-1B-Instruct-INT8-compressed-tensors.yaml\n│ │ │ ├── Meta-Llama-4-Maverick-17B-128E-Instruct-FP8-MM.yaml\n│ │ │ ├── Meta-Llama-4-Maverick-17B-128E-Instruct-FP8.yaml\n│ │ │ ├── Minitron-4B-Base-FP8.yaml\n│ │ │ ├── Mixtral-8x22B-Instruct-v0.1-FP8-Dynamic.yaml\n│ │ │ ├── Mixtral-8x7B-Instruct-v0.1-FP8.yaml\n│ │ │ ├── Mixtral-8x7B-Instruct-v0.1.yaml\n│ │ │ ├── models-large-hopper.txt\n│ │ │ ├── models-large-rocm-fp8.txt\n│ │ │ ├── models-large-rocm.txt\n│ │ │ ├── models-large.txt\n│ │ │ ├── models-mm-large-h100.txt\n│ │ │ ├── models-mm-small.txt\n│ │ │ ├── models-small-rocm.txt\n│ │ │ ├── models-small.txt\n│ │ │ ├── NVIDIA-Nemotron-3-Nano-30B-A3B-BF16.yaml\n│ │ │ ├── NVIDIA-Nemotron-3-Nano-30B-A3B-FP8.yaml\n│ │ │ ├── Qwen1.5-MoE-W4A16-compressed-tensors.yaml\n│ │ │ ├── Qwen2-1.5B-Instruct-FP8W8.yaml\n│ │ │ ├── Qwen2-1.5B-Instruct-INT8-compressed-tensors.yaml\n│ │ │ ├── Qwen2-57B-A14-Instruct.yaml\n│ │ │ ├── Qwen2.5-1.5B-Instruct.yaml\n│ │ │ ├── Qwen2.5-VL-3B-Instruct-FP8-dynamic.yaml\n│ │ │ ├── Qwen2.5-VL-7B-Instruct.yaml\n│ │ │ └── Qwen3-235B-A22B-Instruct-2507-FP8.yaml\n│ │ ├── conftest.py\n│ │ ├── run-lm-eval-chartqa-vllm-vlm-baseline.sh\n│ │ ├── run-lm-eval-gsm-hf-baseline.sh\n│ │ ├── run-lm-eval-gsm-vllm-baseline.sh\n│ │ ├── run-lm-eval-mmlupro-vllm-baseline.sh\n│ │ └── test_lm_eval_correctness.py\n│ ├── performance-benchmarks\n│ │ ├── scripts\n│ │ │ ├── compare-json-results.py\n│ │ │ ├── convert-results-json-to-markdown.py\n│ │ │ ├── launch-server.sh\n│ │ │ └── run-performance-benchmarks.sh\n│ │ ├── tests\n│ │ │ ├── genai-perf-tests.json\n│ │ │ ├── latency-tests-arm64-cpu.json\n│ │ │ ├── latency-tests-cpu.json\n│ │ │ ├── latency-tests-hpu.json\n│ │ │ ├── latency-tests.json\n│ │ │ ├── nightly-tests.json\n│ │ │ ├── serving-tests-arm64-cpu.json\n│ │ │ ├── serving-tests-cpu-asr.json\n│ │ │ ├── serving-tests-cpu-embed.json\n│ │ │ ├── serving-tests-cpu-text.json\n│ │ │ ├── serving-tests-cpu.json\n│ │ │ ├── serving-tests-hpu.json\n│ │ │ ├── serving-tests.json\n│ │ │ ├── throughput-tests-arm64-cpu.json\n│ │ │ ├── throughput-tests-cpu.json\n│ │ │ ├── throughput-tests-hpu.json\n│ │ │ └── throughput-tests.json\n│ │ ├── performance-benchmarks-descriptions.md\n│ │ └── README.md\n│ ├── scripts\n│ │ ├── hardware_ci\n│ │ │ ├── run-amd-test.sh\n│ │ │ ├── run-cpu-compatibility-test.sh\n│ │ │ ├── run-cpu-distributed-smoke-test.sh\n│ │ │ ├── run-cpu-test-arm.sh\n│ │ │ ├── run-cpu-test-ppc64le.sh\n│ │ │ ├── run-cpu-test-s390x.sh\n│ │ │ ├── run-cpu-test.sh\n│ │ │ ├── run-gh200-test.sh\n│ │ │ ├── run-hpu-test.sh\n│ │ │ ├── run-intel-ci-test.sh\n│ │ │ ├── run-intel-test.sh\n│ │ │ ├── run-npu-test.sh\n│ │ │ ├── run-tpu-v1-test-part2.sh\n│ │ │ └── run-tpu-v1-test.sh\n│ │ ├── lib\n│ │ │ ├── manylinux.sh\n\nREADME 摘录:\n<!-- markdownlint-disable MD001 MD041 -->\n<p align=\"center\">\n \n</p>\n\n<h3 align=\"center\">\nEasy, fast, and cheap LLM serving for everyone\n</h3>\n\n<p align=\"center\">\n| <a href=\"https://docs.vllm.ai\"><b>Documentation</b></a> | <a href=\"https://blog.vllm.ai/\"><b>Blog</b></a> | <a href=\"https://arxiv.org/abs/2309.06180\"><b>Paper</b></a> | <a href=\"https://x.com/vllm_project\"><b>Twitter/X</b></a> | <a href=\"https://discuss.vllm.ai\"><b>User Forum</b></a> | <a href=\"https://slack.vllm.ai\"><b>Developer Slack</b></a> |\n</p>\n\n🔥 We have built a vLLM website to help you get started with vLLM. Please visit [vllm.ai](https://vllm.ai) to learn more.\nFor events, please visit [vllm.ai/events](https://vllm.ai/events) to join us.\n\n---\n\n## About\n\nvLLM is a fast and easy-to-use library for LLM inference and serving.\n\nOriginally developed in the [Sky Computing Lab](https://sky.cs.berkeley.edu) at UC Berkeley, vLLM has grown into one of the most active open-source AI projects built and maintained by a diverse community of many dozens of academic institutions and companies from over 2000 contributors.\n\nvLLM is fast with:\n\n- State-of-the-art serving throughput\n- Efficient management of attention key and value memory with [**PagedAttention**](https://blog.vllm.ai/2023/06/20/vllm.html)\n- Continuous batching of incoming requests, chunked prefill, prefix caching\n- Fast and flexible model execution with piecewise and full CUDA/HIP graphs\n- Quantization: FP8, MXFP8/MXFP4, NVFP4, INT8, INT4, GPTQ/AWQ, GGUF, compressed-tensors, ModelOpt, TorchAO, and [more](https://docs.vllm.ai/en/latest/features/quantization/index.html)\n- Optimized attention kernels including FlashAttention, FlashInfer, TRTLLM-GEN, FlashMLA, and Triton\n- Optimized GEMM/MoE kernels for various precisions using CUTLASS, TRTLLM-GEN, CuTeDSL\n- Speculative decoding including n-gram, suffix, EAGLE, DFlash\n- Automatic kernel generation and graph-level transformations using torch.compile\n- Disaggregated prefill, decode, and encode\n\nvLLM is flexible and easy to use with:\n\n- Seamless integration with popular Hugging Face models\n- High-throughput serving with various decoding algorithms, including *parallel sampling*, *beam search*, and more\n- Tensor, pipeline, data, expert, and context parallelism for distributed inference\n- Streaming outputs\n- Generation of structured outputs using xgrammar or guidance\n- Tool calling and reasoning parsers\n- OpenAI-compatible API server, plus Anthropic Messages API and gRPC support\n- Efficient multi-LoRA support for dense and MoE layers\n- Support for NVIDIA GPUs, AMD GPUs, and x86/ARM/PowerPC CPUs. Additionally, diverse hardware plugins such as Google TPUs, Intel Gaudi, IBM Spyre, Huawei Ascend, Rebellions NPU, Apple Silicon, MetaX GPU, and more.\n\nvLLM seamlessly supports 200+ model architectures on Hugging Face, including:\n\n- Decoder-only LLMs (e.g., Llama, Qwen, Gemma)\n- Mixture-of-Expert LLMs (e.g., Mixtral, DeepSeek-V3, Qwen-MoE, GPT-OSS)\n- Hybrid attention and state-space models (e.g., Mamba, Qwen3.5)\n- Multi-modal models (e.g., LLaVA, Qwen-VL, Pixtral)\n- Embedding and retrieval models (e.g., E5-Mistral, GTE, ColBERT)\n- Reward and classification models (e.g., Qwen-Math)\n\nFind the full list of supported models [here](https://docs.vllm.ai/en/latest/models/supported_models.html).\n\n## Getting Started\n\nInstall vLLM with [`uv`](https://docs.astral.sh/uv/) (recommended) or `pip`:\n\nOr [build from source](https://docs.vllm.ai/en/latest/getting_started/installation/gpu/index.html#build-wheel-from-source) for development.\n\nVisit our [documentation](https://docs.vllm.ai/en/latest/) to learn more.\n\n- [Installation](https://docs.vllm.ai/en/latest/getting_started/installation.html)\n- [Quickstart](https://docs.vllm.ai/en/latest/getting_started/quickstart.html)\n- [List of Supported Models](https://docs.vllm.ai/en/latest/models/supported_models.html)\n\n## Contributing\n\nWe welcome and value any contributions and collaborations.\nPlease check out [Contributing to vLLM](https://docs.vllm.ai/en/latest/contributing/index.html) for how to get involved.\n\n## Citation\n\nIf you use vLLM for your research, please cite our [paper](https://arxiv.org/abs/2309.06180):\n\n## Contact Us\n\n<!-- --8<-- [start:contact-us] -->\n- For technical questions and feature requests, please use GitHub [Issues](https://github.com/vllm-project/vllm/issues)\n- For discussing with fellow users, please use the [vLLM Forum](https://discuss.vllm.ai)\n- For coordinating contributions and development, please use [Slack](https://slack.vllm.ai)\n- For security disclosures, please use GitHub's [Security Advisories](https://github.com/vllm-project/vllm/security/advisories) feature\n- For collaborations and partnerships, please contact us at [collaboration@vllm.ai](mailto:collaboration@vllm.ai)\n<!-- --8<-- [end:contact-us] -->\n\n## Media Kit\n\n- If you wish to use vLLM's logo, please refer to [our media kit repo](https://github.com/vllm-project/media-kit)\n"
}
],
"json_schema": {
"title": "repo_knowledge_extraction",
"type": "object",
"additionalProperties": false,
"required": [
"repo_name",
"repo_url",
"repo_category",
"summary",
"learning_value",
"prerequisites",
"knowledge_points",
"suggested_learning_path",
"relevant_directories",
"tags"
],
"properties": {
"repo_name": {
"type": "string"
},
"repo_url": {
"type": "string"
},
"repo_category": {
"type": "string"
},
"summary": {
"type": "string"
},
"learning_value": {
"type": "string"
},
"prerequisites": {
"type": "array",
"items": {
"type": "string"
}
},
"knowledge_points": {
"type": "array",
"items": {
"type": "object",
"additionalProperties": false,
"required": [
"name",
"category",
"description",
"importance",
"evidence"
],
"properties": {
"name": {
"type": "string"
},
"category": {
"type": "string"
},
"description": {
"type": "string"
},
"importance": {
"type": "string"
},
"evidence": {
"type": "string"
}
}
}
},
"suggested_learning_path": {
"type": "array",
"items": {
"type": "string"
}
},
"relevant_directories": {
"type": "array",
"items": {
"type": "string"
}
},
"tags": {
"type": "array",
"items": {
"type": "string"
}
}
}
}
}
\ No newline at end of file
{
"title": "repo_knowledge_extraction",
"type": "object",
"additionalProperties": false,
"required": [
"repo_name",
"repo_url",
"repo_category",
"summary",
"learning_value",
"prerequisites",
"knowledge_points",
"suggested_learning_path",
"relevant_directories",
"tags"
],
"properties": {
"repo_name": {
"type": "string"
},
"repo_url": {
"type": "string"
},
"repo_category": {
"type": "string"
},
"summary": {
"type": "string"
},
"learning_value": {
"type": "string"
},
"prerequisites": {
"type": "array",
"items": {
"type": "string"
}
},
"knowledge_points": {
"type": "array",
"items": {
"type": "object",
"additionalProperties": false,
"required": [
"name",
"category",
"description",
"importance",
"evidence"
],
"properties": {
"name": {
"type": "string"
},
"category": {
"type": "string"
},
"description": {
"type": "string"
},
"importance": {
"type": "string"
},
"evidence": {
"type": "string"
}
}
}
},
"suggested_learning_path": {
"type": "array",
"items": {
"type": "string"
}
},
"relevant_directories": {
"type": "array",
"items": {
"type": "string"
}
},
"tags": {
"type": "array",
"items": {
"type": "string"
}
}
}
}
\ No newline at end of file
{
"repo_name": "airflow",
"repo_url": "https://github.com/apache/airflow",
"stars": 46099,
"primary_language": "Python",
"updated_at": "2026-07-13T08:02:43Z",
"readme_text": "<!--\n Licensed to the Apache Software Foundation (ASF) under one\n or more contributor license agreements. See the NOTICE file\n distributed with this work for additional information\n regarding copyright ownership. The ASF licenses this file\n to you under the Apache License, Version 2.0 (the\n \"License\"); you may not use this file except in compliance\n with the License. You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing,\n software distributed under the License is distributed on an\n \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n KIND, either express or implied. See the License for the\n specific language governing permissions and limitations\n under the License.\n-->\n\n<!-- START Apache Airflow, please keep comment here to allow auto update of PyPI readme.md -->\n# Apache Airflow\n\n| Category | Badges |\n|------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| License | [![License](https://img.shields.io/:license-Apache%202-blue.svg)](https://www.apache.org/licenses/LICENSE-2.0.txt) |\n| PyPI | [![PyPI version](https://badge.fury.io/py/apache-airflow.svg)](https://badge.fury.io/py/apache-airflow) [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/apache-airflow.svg)](https://pypi.org/project/apache-airflow/) [![PyPI - Downloads](https://img.shields.io/pypi/dm/apache-airflow)](https://pypi.org/project/apache-airflow/) |\n| Containers | [![Docker Pulls](https://img.shields.io/docker/pulls/apache/airflow.svg)](https://hub.docker.com/r/apache/airflow) [![Docker Stars](https://img.shields.io/docker/stars/apache/airflow.svg)](https://hub.docker.com/r/apache/airflow) [![Artifact HUB](https://img.shields.io/endpoint?url=https://artifacthub.io/badge/repository/apache-airflow)](https://artifacthub.io/packages/search?repo=apache-airflow) |\n| Community | [![Contributors](https://img.shields.io/github/contributors/apache/airflow)](https://github.com/apache/airflow/graphs/contributors) [![Slack Status](https://img.shields.io/badge/slack-join_chat-white.svg?logo=slack&style=social)](https://s.apache.org/airflow-slack) ![Commit Activity](https://img.shields.io/github/commit-activity/m/apache/airflow) [![LFX Health Score](https://insights.linuxfoundation.org/api/badge/health-score?project=apache-airflow)](https://insights.linuxfoundation.org/project/apache-airflow) |\n| Dev tools | [![prek](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/j178/prek/master/docs/assets/badge-v0.json)](https://github.com/j178/prek) |\n\n| Version | Build Status |\n|---------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| Main | [![Tests AMD main](https://github.com/apache/airflow/actions/workflows/ci-amd.yml/badge.svg)](https://github.com/apache/airflow/actions/workflows/ci-amd.yml) [![Tests ARM main](https://github.com/apache/airflow/actions/workflows/ci-arm.yml/badge.svg)](https://github.com/apache/airflow/actions/workflows/ci-arm.yml) |\n| 3.x | [![Tests AMD 3.2](https://github.com/apache/airflow/actions/workflows/ci-amd.yml/badge.svg?branch=v3-2-test)](https://github.com/apache/airflow/actions/workflows/ci-amd.yml) [![Tests ARM 3.2](https://github.com/apache/airflow/actions/workflows/ci-arm.yml/badge.svg?branch=v3-2-test)](https://github.com/apache/airflow/actions/workflows/ci-arm.yml) |\n\n\n\n<picture width=\"500\">\n <img\n src=\"https://github.com/apache/airflow/blob/19ebcac2395ef9a6b6ded3a2faa29dc960c1e635/docs/apache-airflow/img/logos/wordmark_1.png?raw=true\"\n alt=\"Apache Airflow logo\"\n />\n</picture>\n\n[Apache Airflow](https://airflow.apache.org/docs/apache-airflow/stable/) (or simply Airflow) is a platform to programmatically author, schedule, and monitor workflows.\n\nWhen workflows are defined as code, they become more maintainable, versionable, testable, and collaborative.\n\nUse Airflow to author workflows (Dags) that orchestrate tasks. The Airflow scheduler executes your tasks on an array of workers while following the specified dependencies. Rich command line utilities make performing complex surgeries on Dags a snap. The rich user interface makes it easy to visualize pipelines running in production, monitor progress, and troubleshoot issues when needed.\n\n<!-- END Apache Airflow, please keep comment here to allow auto update of PyPI readme.md -->\n<!-- START doctoc generated TOC please keep comment here to allow auto update -->\n<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->\n**Table of contents**\n\n- [Project Focus](#project-focus)\n- [Principles](#principles)\n- [Requirements](#requirements)\n- [Getting started](#getting-started)\n- [Installing from PyPI](#installing-from-pypi)\n- [Installation](#installation)\n- [Official source code](#official-source-code)\n- [Convenience packages](#convenience-packages)\n- [User Interface](#user-interface)\n- [Semantic versioning](#semantic-versioning)\n- [Version Life Cycle](#version-life-cycle)\n- [Support for Python and Kubernetes versions](#support-for-python-and-kubernetes-versions)\n- [Base OS support for reference Airflow images](#base-os-support-for-reference-airflow-images)\n- [Approach to dependencies of Airflow](#approach-to-dependencies-of-airflow)\n- [Contributing](#contributing)\n- [Community standards](#community-standards)\n- [Agent-assisted contribution (apache-magpie)](#agent-assisted-contribution-apache-magpie)\n- [Voting Policy](#voting-policy)\n- [Who uses Apache Airflow?](#who-uses-apache-airflow)\n- [Who maintains Apache Airflow?](#who-maintains-apache-airflow)\n- [What goes into the next release?](#what-goes-into-the-next-release)\n- [Can I use the Apache Airflow logo in my presentation?](#can-i-use-the-apache-airflow-logo-in-my-presentation)\n- [Links](#links)\n- [Sponsors](#sponsors)\n\n<!-- END doctoc generated TOC please keep comment here to allow auto update -->\n\n## Project Focus\n\nAirflow works best with workflows that are mostly static and slowly changing. When the Dag structure is similar from one run to the next, it clarifies the unit of work and continuity. Other similar projects include [Luigi](https://github.com/spotify/luigi), [Oozie](https://oozie.apache.org/) and [Azkaban](https://azkaban.github.io/).\n\nAirflow is commonly used to process data, but has the opinion that tasks should ideally be idempotent (i.e., results of the task will be the same, and will not create duplicated data in a destination system), and should not pass large quantities of data from one task to the next (though tasks can pass metadata using Airflow's [XCom feature](https://airflow.apache.org/docs/apache-airflow/stable/concepts/xcoms.html)). For high-volume, data-intensive tasks, a best practice is to delegate to external services specializing in that type of work.\n\nAirflow is not a streaming solution, but it is often used to process real-time data, pulling data off streams in batches.\n\n## Principles\n\n- **Dynamic**: Pipelines are defined in code, enabling dynamic dag generation and parameterization.\n- **Extensible**: The Airflow framework includes a wide range of built-in operators and can be extended to fit your needs.\n- **Flexible**: Airflow leverages the [**Jinja**](https://jinja.palletsprojects.com) templating engine, allowing rich customizations.\n\n<!-- START Requirements, please keep comment here to allow auto update of PyPI readme.md -->\n## Requirements\n\nApache Airflow is tested with:\n\n| | Main version (dev) | Stable version (3.3.0) | Deprecate version (2.11.2) |\n|------------|------------------------------------|-------------------------------------|------------------------------|\n| Python | 3.10, 3.11, 3.12, 3.13, 3.14 | 3.10, 3.11, 3.12, 3.13, 3.14 | 3.10, 3.11, 3.12 |\n| Platform | AMD64/ARM64 | AMD64/ARM64 | AMD64/ARM64(\\*) |\n| Kubernetes | 1.30, 1.31, 1.32, 1.33, 1.34, 1.35 | 1.30, 1.31, 1.32, 1.33, 1.34, 1.35 | 1.26, 1.27, 1.28, 1.29, 1.30 |\n| PostgreSQL | 14, 15, 16, 17, 18 | 14, 15, 16, 17, 18 | 12, 13, 14, 15, 16 |\n| MySQL | 8.0, 8.4, Innovation | 8.0, 8.4, Innovation | 8.0, Innovation |\n| SQLite | 3.15.0+ | 3.15.0+ | 3.15.0+ |\n\n\\* Experimental\n\n**Note**: MariaDB is not tested/recommended.\n\n**Note**: SQLite is used in Airflow tests. Do not use it in production. We recommend\nusing the latest stable version of SQLite for local development.\n\n**Note**: Airflow currently can be run on POSIX-compliant Operating Systems. For development, it is regularly\ntested on fairly modern Linux Distros and recent versions of macOS.\nOn Windows you can run it via WSL2 (Windows Subsystem for Linux 2) or via Linux Containers.\nThe work to add Windows support is tracked via [#10388](https://github.com/apache/airflow/issues/10388), but\nit is not a high priority. You should only use Linux-based distros as \"Production\" execution environment\nas this is the only environment that is supported. The only distro that is used in our CI tests and that\nis used in the [Community managed DockerHub image](https://hub.docker.com/p/apache/airflow) is\n`Debian Bookworm`.\n\n<!-- END Requirements, please keep comment here to allow auto update of PyPI readme.md -->\n<!-- START Getting started, please keep comment here to allow auto update of PyPI readme.md -->\n## Getting started\n\nVisit the official Airflow website documentation (latest **stable** release) for help with\n[installing Airflow](https://airflow.apache.org/docs/apache-airflow/stable/installation/),\n[getting started](https://airflow.apache.org/docs/apache-airflow/stable/start.html), or walking\nthrough a more complete [tutorial](https://airflow.apache.org/docs/apache-airflow/stable/tutorial/).\n\n> Note: If you're looking for documentation for the main branch (latest development branch): you can find it on [s.apache.org/airflow-docs](https://s.apache.org/airflow-docs/).\n\nFor more information on Airflow Improvement Proposals (AIPs), visit\nthe [Airflow Wiki](https://cwiki.apache.org/confluence/display/AIRFLOW/Airflow+Improvement+Proposals).\n\nDocumentation for dependent projects like provider distributions, Docker image, Helm Chart, you'll find it in [the documentation index](https://airflow.apache.org/docs/).\n\n<!-- END Getting started, please keep comment here to allow auto update of PyPI readme.md -->\n<!-- START Installing from PyPI, please keep comment here to allow auto update of PyPI readme.md -->\n\n## Installing from PyPI\n\nWe publish Apache Airflow as `apache-airflow` package in PyPI. Installing it however might be sometimes tricky\nbecause Airflow is a bit of both a library and application. Libraries usually keep their dependencies open, and\napplications usually pin them, but we should do neither and both simultaneously. We decided to keep\nour dependencies as open as possible (in `pyproject.toml`) so users can install different versions of libraries\nif needed. This means that `pip install apache-airflow` will not work from time to time or will\nproduce unusable Airflow installation.\n\nTo have repeatable installation, however, we keep a set of \"known-to-be-working\" constraint\nfiles in the orphan `constraints-main` and `constraints-2-0` branches. We keep those \"known-to-be-working\"\nconstraints files separately per major/minor Python version.\nYou can use them as constraint files when installing Airflow from PyPI. Note that you have to specify\ncorrect Airflow tag/version/branch and Python versions in the URL.\n\n1. Installing just Airflow:\n\n> Note: Only `pip` installation is currently officially supported.\n\nWhile it is possible to install Airflow with tools like [Poetry](https://python-poetry.org) or\n[pip-tools](https://pypi.org/project/pip-tools), they do not share the same workflow as\n`pip` - especially when it comes to constraint vs. requirements management.\nInstalling via `Poetry` or `pip-tools` is not currently supported.\n\nIf you wish to install Airflow using those tools, you should use the constraint files and convert\nthem to the appropriate format and workflow that your tool requires.\n\n\n```bash\npip install 'apache-airflow==3.3.0' \\\n --constraint \"https://raw.githubusercontent.com/apache/airflow/constraints-3.3.0/constraints-3.10.txt\"\n```\n\n2. Installing with extras (i.e., postgres, google)\n\n```bash\npip install 'apache-airflow[postgres,google]==3.3.0' \\\n --constraint \"https://raw.githubusercontent.com/apache/airflow/constraints-3.3.0/constraints-3.10.txt\"\n```\n\nFor information on installing provider distributions, check\n[providers](http://airflow.apache.org/docs/apache-airflow-providers/index.html).\n\n<!-- END Installing from PyPI, please keep comment here to allow auto update of PyPI readme.md -->\n\n## Installation\n\nFor comprehensive instructions on setting up your local development environment and installing Apache Airflow, please refer to the [INSTALLING.md](INSTALLING.md) file.\n\n<!-- START Official source code, please keep comment here to allow auto update of PyPI readme.md -->\n## Official source code\n\nApache Airflow is an [Apache Software Foundation](https://www.apache.org) (ASF) project,\nand our official source code releases:\n\n- Follow the [ASF Release Policy](https://www.apache.org/legal/release-policy.html)\n- Can be downloaded from [the ASF Distribution Directory](https://downloads.apache.org/airflow)\n- Are cryptographically signed by the release manager\n- Are officially voted on by the PMC members during the\n [Release Approval Process](https://www.apache.org/legal/release-policy.html#release-approval)\n\nFollowing the ASF rules, the source packages released must be sufficient for a user to build and test the\nrelease provided they have access to the appropriate platform and tools.\n\n<!-- END Official source code, please keep comment here to allow auto update of PyPI readme.md -->\n## Convenience packages\n\nThere are other ways of installing and using Airflow. Those are \"convenience\" methods - they are\nnot \"official releases\" as stated by the `ASF Release Policy`, but they can be used by the users\nwho do not want to build the software themselves.\n\nThose are - in the order of most common ways people install Airflow:\n\n- [PyPI releases](https://pypi.org/project/apache-airflow/) to install Airflow using standard `pip` tool\n- [Docker Images](https://hub.docker.com/r/apache/airflow) to install airflow via\n `docker` tool, use them in Kubernetes, Helm Charts, `docker-compose`, `docker swarm`, etc. You can\n read more about using, customizing, and extending the images in the\n [Latest docs](https://airflow.apache.org/docs/docker-stack/index.html), and\n learn details on the internals in the [images](https://airflow.apache.org/docs/docker-stack/index.html) document.\n- [Tags in GitHub](https://github.com/apache/airflow/tags) to retrieve the git project sources that\n were used to generate official source packages via git\n\nAll those artifacts are not official releases, but they are prepared using officially released sources.\nSome of those artifacts are \"development\" or \"pre-release\" ones, and they are clearly marked as such\nfollowing the ASF Policy.\n\n## User Interface\n\n- **Dags**: Overview of all Dags in your environment.\n\n ![Dags](https://raw.githubusercontent.com/apache/airflow/main/airflow-core/docs/img/ui-dark/dags.png)\n\n- **Assets**: Overview of Assets with dependencies.\n\n ![Asset Dependencies](https://raw.githubusercontent.com/apache/airflow/main/airflow-core/docs/img/ui-dark/assets_graph.png)\n\n- **Grid**: Grid representation of a Dag that spans across time.\n\n ![Grid](https://raw.githubusercontent.com/apache/airflow/main/airflow-core/docs/img/ui-dark/grid.png)\n\n- **Graph**: Visualization of a Dag's dependencies and their current status for a specific run.\n\n ![Graph](https://raw.githubusercontent.com/apache/airflow/main/airflow-core/docs/img/ui-dark/graph.png)\n\n- **Home**: Summary statistics of your Airflow environment.\n\n ![Home](https://raw.githubusercontent.com/apache/airflow/main/airflow-core/docs/img/ui-dark/home.png)\n\n- **Backfill**: Backfilling a Dag for a specific date range.\n\n ![Backfill](https://raw.githubusercontent.com/apache/airflow/main/airflow-core/docs/img/ui-dark/backfill.png)\n\n- **Code**: Quick way to view source code of a Dag.\n\n ![Code](https://raw.githubusercontent.com/apache/airflow/main/airflow-core/docs/img/ui-dark/code.png)\n\n## Semantic versioning\n\nAs of Airflow 2.0.0, we support a strict [SemVer](https://semver.org/) approach for all packages released.\n\nThere are few specific rules that we agreed to that define details of versioning of the different\npackages:\n\n* **Airflow**: SemVer rules apply to core airflow only (excludes any changes to providers).\n Changing limits for versions of Airflow dependencies is not a breaking change on its own.\n* **Airflow Providers**: SemVer rules apply to changes in the particular provider's code only.\n SemVer MAJOR and MINOR versions for the packages are independent of the Airflow version.\n For example, `google 4.1.0` and `amazon 3.1.1` providers can happily be installed\n with `Airflow 2.1.2`. If there are limits of cross-dependencies between providers and Airflow packages,\n they are present in providers as `install_requires` limitations. We aim to keep backwards\n compatibility of providers with all previously released Airflow 2 versions but\n there will sometimes be breaking changes that might make some, or all\n providers, have minimum Airflow version specified.\n* **Airflow Helm Chart**: SemVer rules apply to changes in the chart only. SemVer MAJOR and MINOR\n versions for the chart are independent of the Airflow version. We aim to keep backwards\n compatibility of the Helm Chart with all released Airflow 2 versions, but some new features might\n only work starting from specific Airflow releases. We might however limit the Helm\n Chart to depend on minimal Airflow version.\n* **Airflow API clients**: Their versioning is independent from Airflow versions. They follow their own\n SemVer rules for breaking changes and new features - which for example allows to change the way we generate\n the clients.\n\n## Version Life Cycle\n\nApache Airflow version life cycle:\n\n<!-- This table is automatically updated by prek scripts/ci/prek/supported_versions.py -->\n<!-- Beginning of auto-generated table -->\n\n| Version | Current Patch/Minor | State | First Release | Limited Maintenance | EOL/Terminated |\n|-----------|-----------------------|-------------|-----------------|-----------------------|------------------|\n| 3 | 3.3.0 | Maintenance | Apr 22, 2025 | TBD | TBD |\n| 2 | 2.11.2 | EOL | Dec 17, 2020 | Oct 22, 2025 | Apr 22, 2026 |\n| 1.10 | 1.10.15 | EOL | Aug 27, 2018 | Dec 17, 2020 | June 17, 2021 |\n| 1.9 | 1.9.0 | EOL | Jan 03, 2018 | Aug 27, 2018 | Aug 27, 2018 |\n| 1.8 | 1.8.2 | EOL | Mar 19, 2017 | Jan 03, 2018 | Jan 03, 2018 |\n| 1.7 | 1.7.1.2 | EOL | Mar 28, 2016 | Mar 19, 2017 | Mar 19, 2017 |\n\n<!-- End of auto-generated table -->\n\nLimited support versions will be supported with security and critical bug fix only.\nEOL versions will not get any fixes nor support.\nWe always recommend that all users run the latest available minor release for whatever major version is in use.\nWe **highly** recommend upgrading to the latest Airflow major release at the earliest convenient time and before the EOL date.\n\n## Support for Python and Kubernetes versions\n\nAs of Airflow 2.0, we agreed to certain rules we follow for Python and Kubernetes support.\nThey are based on the official release schedule of Python and Kubernetes, nicely summarized in the\n[Python Developer's Guide](https://devguide.python.org/#status-of-python-branches) and\n[Kubernetes version skew policy](https://kubernetes.io/docs/setup/release/version-skew-policy/).\n\n1. We drop support for Python and Kubernetes versions when they reach EOL. Except for Kubernetes, a\n version stays supported by Airflow if two major cloud providers still provide support for it. We drop\n support for those EOL versions in main right after EOL date, and it is effectively removed when we release\n the first new MINOR (Or MAJOR if there is no new MINOR version) of Airflow. For example, for Python 3.10 it\n means that we will drop support in main right after 27.06.2023, and the first MAJOR or MINOR version of\n Airflow released after will not have it.\n\n2. We support a new version of Python/Kubernetes in main after they are officially released, as soon as we\n make them work in our CI pipeline (which might not be immediate due to dependencies catching up with\n new versions of Python mostly) we release new images/support in Airflow based on the working CI setup.\n\n3. This policy is best-effort which means there may be situations where we might terminate support earlier\n if circumstances require it.\n\n## Base OS support for reference Airflow images\n\nThe Airflow Community provides conveniently packaged container images that are published whenever\nwe publish an Apache Airflow release. Those images contain:\n\n* Base OS with necessary packages to install Airflow (stable Debian OS)\n* Base Python installation in versions supported at the time of release for the MINOR version of\n Airflow released (so there could be different versions for 2.3 and 2.2 line for example)\n* Libraries required to connect to supported Databases (again the set of databases supported depends\n on the MINOR version of Airflow)\n* Predefined set of popular providers (for details see the [Dockerfile](https://raw.githubusercontent.com/apache/airflow/main/Dockerfile)).\n* Possibility of building your own, custom image where the user can choose their own set of providers\n and libraries (see [Building the image](https://airflow.apache.org/docs/docker-stack/build.html))\n* In the future Airflow might also support a \"slim\" version without providers nor database clients installed\n\nThe version of the base OS image is the stable version of Debian. Airflow supports using all currently active\nstable versions - as soon as all Airflow dependencies support building, and we set up the CI pipeline for\nbuilding and testing the OS version. Approximately 6 months before the end-of-regular support of a\nprevious stable version of the OS, Airflow switches the images released to use the latest supported\nversion of the OS.\n\nFor example switch from ``Debian Bullseye`` to ``Debian Bookworm`` has been implemented\nbefore 2.8.0 release in October 2023 and ``Debian Bookworm`` will be the only option supported as of\nAirflow 2.10.0.\n\nUsers will continue to be able to build their images using stable Debian releases until the end of regular\nsupport and building and verifying of the images happens in our CI but no unit tests were executed using\nthis image in the `main` branch.\n\n## Approach to dependencies of Airflow\n\nAirflow has a lot of dependencies - direct and transitive, also Airflow is both - library and application,\ntherefore our policies to dependencies has to include both - stability of installation of application,\nbut also ability to install newer version of dependencies for those users who develop Dags. We developed\nthe approach where `constraints` are used to make sure airflow can be installed in a repeatable way, while\nwe do not limit our users to upgrade most of the dependencies. As a result we decided not to upper-bound\nversion of Airflow dependencies by default, unless we have good reasons to believe upper-bounding them is\nneeded because of importance of the dependency as well as risk it involves to upgrade specific dependency.\nWe also upper-bound the dependencies that we know cause problems.\n\nThe constraint mechanism of ours takes care about finding and upgrading all the non-upper bound dependencies\nautomatically (providing that all the tests pass). Our `main` build failures will indicate in case there\nare versions of dependencies that break our tests - indicating that we should either upper-bind them or\nthat we should fix our code/tests to account for the upstream changes from those dependencies.\n\nWhenever we upper-bound such a dependency, we should always comment why we are doing it - i.e. we should have\na good reason why dependency is upper-bound. And we should also mention what is the condition to remove the\nbinding.\n\n### Approach for dependencies for Airflow Core\n\nThose dependencies are maintained in ``pyproject.toml``.\n\nThere are few dependencies that we decided are important enough to upper-bound them by default, as they are\nknown to follow predictable versioning scheme, and we know that new versions of those are very likely to\nbring breaking changes. We commit to regularly review and attempt to upgrade to the newer versions of\nthe dependencies as they are released, but this is manual process.\n\nThe important dependencies are:\n\n* `SQLAlchemy`: upper-bound to specific MINOR version (SQLAlchemy is known to remove deprecations and\n introduce breaking changes especially that support for different Databases varies and changes at\n various speed)\n* `Alembic`: it is important to handle our migrations in predictable and performant way. It is developed\n together with SQLAlchemy. Our experience with Alembic is that it very stable in MINOR version\n* `Flask`: We are using Flask as the back-bone of our web UI and API. We know major version of Flask\n are very likely to introduce breaking changes across those so limiting it to MAJOR version makes sense\n* `werkzeug`: the library is known to cause problems in new versions. It is tightly coupled with Flask\n libraries, and we should update them together\n* `celery`: Celery is a crucial component of Airflow as it used for CeleryExecutor (and similar). Celery\n [follows SemVer](https://docs.celeryq.dev/en/stable/contributing.html?highlight=semver#versions), so\n we should upper-bound it to the next MAJOR version. Also, when we bump the upper version of the library,\n we should make sure Celery Provider minimum Airflow version is updated.\n* `kubernetes`: Kubernetes is a crucial component of Airflow as it is used for the KubernetesExecutor\n (and similar). Kubernetes Python library [follows SemVer](https://github.com/kubernetes-client/python#compatibility),\n so we should upper-bound it to the next MAJOR version. Also, when we bump the upper version of the library,\n we should make sure Kubernetes Provider minimum Airflow version is updated.\n\n### Approach for dependencies in Airflow Providers and extras\n\nThe main part of the Airflow is the Airflow Core, but the power of Airflow also comes from a number of\nproviders that extend the core functionality and are released separately, even if we keep them (for now)\nin the same monorepo for convenience. You can read more about the providers in the\n[Providers documentation](https://airflow.apache.org/docs/apache-airflow-providers/index.html). We also\nhave set of policies implemented for maintaining and releasing community-managed providers as well\nas the approach for community vs. 3rd party providers in the [providers](https://github.com/apache/airflow/blob/main/PROVIDERS.rst) document.\n\nThose `extras` and `providers` dependencies are maintained in `provider.yaml` of each provider.\n\nBy default, we should not upper-bound dependencies for providers, however each provider's maintainer\nmight decide to add additional limits (and justify them with comment).\n\n<!-- START Contributing, please keep comment here to allow auto update of PyPI readme.md -->\n\n## Contributing\n\nWant to help build Apache Airflow? Check out our [contributors' guide](https://github.com/apache/airflow/blob/main/contributing-docs/README.rst) for a comprehensive overview of how to contribute, including setup instructions, coding standards, and pull request guidelines.\n\nIf you can't wait to contribute, and want to get started asap, check out the [contribution quickstart](https://github.com/apache/airflow/blob/main/contributing-docs/03a_contributors_quick_start_beginners.rst) here!\n\nOfficial Docker (container) images for Apache Airflow are described in [images](https://github.com/apache/airflow/blob/main/dev/breeze/doc/ci/02_images.md).\n\n<!-- END Contributing, please keep comment here to allow auto update of PyPI readme.md -->\n\n## Community standards\n\nEveryone interacting with the Apache Airflow project — on GitHub, the\nmailing lists, Slack, the CWiki, or anywhere else — is expected to\nfollow the [Code of Conduct](CODE_OF_CONDUCT.md).\n\nWhen repeated Code of Conduct breaches, spamming, abuse of project\nresources, or other sustained disruptive behaviour cannot be resolved\nthrough normal review and mentoring, the project applies the\n[Community escalation process](COMMUNITY_ESCALATION.md). It describes\nthe steps maintainers and the PMC may take — from direct feedback,\nthrough closing PRs, up to PMC-level or ASF-Infrastructure-level\nblocks and reporting accounts to GitHub — and how affected\ncontributors can appeal a decision by emailing the PMC at\n`private@airflow.apache.org`.\n\n## Agent-assisted contribution (apache-magpie)\n\nThis repo adopts the [`apache/magpie`](https://github.com/apache/magpie)\nframework via a snapshot mechanism. The framework provides\nmaintainer-facing PR-management skills (`pr-management-triage`,\n`pr-management-code-review`, `pr-management-stats`, `pr-management-mentor`)\nthat are exposed as agent skills in agent harnesses such as Claude Code.\n\nThe framework is **not** vendored — it lives as a gitignored snapshot\nunder `.apache-magpie/`, fetched on demand from the version pinned in\nthe committed [`.apache-magpie.lock`](.apache-magpie.lock). The only\nframework artefact committed to this repo is the `magpie-setup` skill\nat [`.github/skills/magpie-setup/`](.github/skills/magpie-setup/);\neverything else is a gitignored symlink the setup skill wires up.\n\nA fresh clone needs the snapshot populated before any framework skill\nis invocable. In your agent harness, run:\n\n```text\n/magpie-setup\n```\n\n(or follow [`.claude/skills/magpie-setup/`](.claude/skills/magpie-setup/))\nto fetch the snapshot per the committed lock, scaffold the gitignored\nsymlinks, and install the post-checkout hook that re-creates them on\neach worktree checkout.\n\nAdopter-specific modifications to framework workflows live in\n[`.apache-magpie-overrides/`](.apache-magpie-overrides/) (committed) —\nnever edit the snapshot directly. Framework changes go via PR to\n[`apache/magpie`](https://github.com/apache/magpie).\n\n<!-- START Who uses Apache Airflow, please keep comment here to allow auto update of PyPI readme.md -->\n\n## Voting Policy\n\n* Commits need a +1 vote from a committer who is not the author\n* When we do AIP voting, both PMC member's and committer's `+1s` are considered a binding vote.\n\n## Who uses Apache Airflow?\n\nWe know about around 500 organizations that are using Apache Airflow (but there are likely many more)\n[in the wild](https://github.com/apache/airflow/blob/main/INTHEWILD.md).\n\nIf you use Airflow - feel free to make a PR to add your organisation to the list.\n\n<!-- END Who uses Apache Airflow, please keep comment here to allow auto update of PyPI readme.md -->\n<!-- START Who maintains Apache Airflow, please keep comment here to allow auto update of PyPI readme.md -->\n\n## Who maintains Apache Airflow?\n\nAirflow is the work of the [community](https://github.com/apache/airflow/graphs/contributors),\nbut the [core committers/maintainers](https://people.apache.org/committers-by-project.html#airflow)\nare responsible for reviewing and merging PRs as well as steering conversations around new feature requests.\nIf you would like to become a maintainer, please review the Apache Airflow\n[committer requirements](https://github.com/apache/airflow/blob/main/COMMITTERS.rst#guidelines-to-become-an-airflow-committer).\n\n<!-- END Who maintains Apache Airflow, please keep comment here to allow auto update of PyPI readme.md -->\n\n## What goes into the next release?\n\nOften you will see an issue that is assigned to specific milestone with Airflow version, or a PR that gets merged\nto the main branch and you might wonder which release the merged PR(s) will be released in or which release the fixed\nissues will be in. The answer to this is as usual - it depends on various scenarios. The answer is different for PRs and Issues.\n\nTo add a bit of context, we are following the [Semver](https://semver.org/) versioning scheme as described in\n[Airflow release process](https://airflow.apache.org/docs/apache-airflow/stable/release-process.html). More\ndetails are explained in detail in this README under the [Semantic versioning](#semantic-versioning) chapter, but\nin short, we have `MAJOR.MINOR.PATCH` versions of Airflow.\n\n* `MAJOR` version is incremented in case of breaking changes\n* `MINOR` version is incremented when there are new features added\n* `PATCH` version is incremented when there are only bug-fixes and doc-only changes\n\nGenerally we release `MINOR` versions of Airflow from a branch that is named after the MINOR version. For example\n`2.7.*` releases are released from `v2-7-stable` branch, `2.8.*` releases are released from `v2-8-stable`\nbranch, etc.\n\n1. Most of the time in our release cycle, when the branch for next `MINOR` branch is not yet created, all\nPRs merged to `main` (unless they get reverted), will find their way to the next `MINOR` release. For example\nif the last release is `2.7.3` and `v2-8-stable` branch is not created yet, the next `MINOR` release\nis `2.8.0` and all PRs merged to main will be released in `2.8.0`. However, some PRs (bug-fixes and\ndoc-only changes) when merged, can be cherry-picked to current `MINOR` branch and released in the\nnext `PATCHLEVEL` release. For example, if `2.8.1` is already released and we are working on `2.9.0dev`, then\nmarking a PR with `2.8.2` milestone means that it will be cherry-picked to `v2-8-test` branch and\nreleased in `2.8.2rc1`, and eventually in `2.8.2`.\n\n2. When we prepare for the next `MINOR` release, we cut new `v2-*-test` and `v2-*-stable` branch\nand prepare `alpha`, `beta` releases for the next `MINOR` version, the PRs merged to main will still be\nreleased in the next `MINOR` release until `rc` version is cut. This is happening because the `v2-*-test`\nand `v2-*-stable` branches are rebased on top of main when next `beta` and `rc` releases are prepared.\nFor example, when we cut `2.10.0beta1` version, anything merged to main before `2.10.0rc1` is released,\nwill find its way to 2.10.0rc1.\n\n3. Then, once we prepare the first RC candidate for the MINOR release, we stop moving the `v2-*-test` and\n`v2-*-stable` branches and the PRs merged to main will be released in the next `MINOR` release.\nHowever, some PRs (bug-fixes and doc-only changes) when merged, can be cherry-picked to current `MINOR`\nbranch and released in the next `PATCHLEVEL` release - for example when the last released version from `v2-10-stable`\nbranch is `2.10.0rc1`, some of the PRs from main can be marked as `2.10.0` milestone by committers,\nthe release manager will try to cherry-pick them into the release branch.\nIf successful, they will be released in `2.10.0rc2` and subsequently in `2.10.0`. This also applies to\nsubsequent `PATCHLEVEL` versions. When for example `2.10.1` is already released, marking a PR with\n`2.10.2` milestone will mean that it will be cherry-picked to `v2-10-stable` branch and released in `2.10.2rc1`\nand eventually in `2.10.2`.\n\nThe final decision about cherry-picking is made by the release manager.\n\nMarking issues with a milestone is a bit different. Maintainers do not mark issues with a milestone usually,\nnormally they are only marked in PRs. If PR linked to the issue (and \"fixing it\") gets merged and released\nin a specific version following the process described above, the issue will be automatically closed, no\nmilestone will be set for the issue, you need to check the PR that fixed the issue to see which version\nit was released in.\n\nHowever, sometimes maintainers mark issues with specific milestone, which means that the\nissue is important to become a candidate to take a look when the release is being prepared. Since this is an\nOpen-Source project, where basically all contributors volunteer their time, there is no guarantee that specific\nissue will be fixed in specific version. We do not want to hold the release because some issue is not fixed,\nso in such case release manager will reassign such unfixed issues to the next milestone in case they are not\nfixed in time for the current release. Therefore, the milestone for issue is more of an intent that it should be\nlooked at, than promise it will be fixed in the version.\n\nMore context and **FAQ** about the patchlevel release can be found in the\n[What goes into the next release](dev/WHAT_GOES_INTO_THE_NEXT_RELEASE.md) document in the `dev` folder of the\nrepository.\n\n## Can I use the Apache Airflow logo in my presentation?\n\nYes! Be sure to abide by the Apache Foundation [trademark policies](https://www.apache.org/foundation/marks/#books) and the Apache Airflow [Brandbook](https://cwiki.apache.org/confluence/display/AIRFLOW/Brandbook). The most up-to-date logos are found in [this repo](https://github.com/apache/airflow/tree/main/airflow-core/docs/img/logos/) and on the Apache Software Foundation [website](https://www.apache.org/logos/about.html).\n\n## Links\n\n- [Documentation](https://airflow.apache.org/docs/apache-airflow/stable/)\n- [Chat](https://s.apache.org/airflow-slack)\n- [Community Information](https://airflow.apache.org/community/)\n\n## Sponsors\n\nThe CI infrastructure for Apache Airflow has been sponsored by:\n\n<!-- Ordered by most recently \"funded\" -->\n\n<a href=\"https://astronomer.io\"><img src=\"https://assets2.astronomer.io/logos/logoForLIGHTbackground.png\" alt=\"astronomer.io\" width=\"250px\"></a>\n<a href=\"https://aws.amazon.com/opensource/\"><img src=\"https://github.com/apache/airflow/blob/main/providers/amazon/docs/integration-logos/AWS-Cloud-alt_light-bg@4x.png?raw=true\" alt=\"AWS OpenSource\" width=\"130px\"></a>",
"directory_tree": "├── .agents\n│ └── skills\n│ ├── aip-user-stories\n│ │ ├── references\n│ │ │ └── playbook-template.md\n│ │ └── SKILL.md\n│ ├── airflow-java-sdk\n│ │ └── SKILL.md\n│ ├── airflow-new-sdk\n│ │ └── SKILL.md\n│ ├── airflow-translations\n│ │ ├── locales\n│ │ │ ├── ar.md\n│ │ │ ├── ca.md\n│ │ │ ├── de.md\n│ │ │ ├── el.md\n│ │ │ ├── es.md\n│ │ │ ├── fr.md\n│ │ │ ├── he.md\n│ │ │ ├── hi.md\n│ │ │ ├── hu.md\n│ │ │ ├── it.md\n│ │ │ ├── ja.md\n│ │ │ ├── ko.md\n│ │ │ ├── nl.md\n│ │ │ ├── pl.md\n│ │ │ ├── pt.md\n│ │ │ ├── th.md\n│ │ │ ├── tr.md\n│ │ │ ├── zh-CN.md\n│ │ │ └── zh-TW.md\n│ │ └── SKILL.md\n│ ├── magpie-setup\n│ │ ├── adopt.md\n│ │ ├── agents.md\n│ │ ├── overrides.md\n│ │ ├── skill-sources.md\n│ │ ├── SKILL.md\n│ │ ├── unadopt.md\n│ │ ├── upgrade.md\n│ │ ├── verify.md\n│ │ └── worktree-init.md\n│ ├── prepare-providers-documentation\n│ │ └── SKILL.md\n│ └── upgrade-fab-provider\n│ └── SKILL.md\n├── .apache-magpie-overrides\n│ ├── pr-management-config.md\n│ ├── pr-management-triage-ci-check-map.md\n│ ├── pr-management-triage-comment-templates.md\n│ ├── README.md\n│ └── setup-isolated-setup-install.md\n├── .claude\n│ └── skills\n│ ├── aip-user-stories\n│ ├── airflow-translations\n│ ├── magpie-setup\n│ ├── prepare-providers-documentation\n│ └── upgrade-fab-provider\n├── .devcontainer\n│ ├── mysql\n│ │ └── devcontainer.json\n│ ├── postgres\n│ │ └── devcontainer.json\n│ └── devcontainer.json\n├── .github\n│ ├── actions\n│ │ ├── breeze\n│ │ │ └── action.yml\n│ │ ├── install-prek\n│ │ │ └── action.yml\n│ │ ├── migration_tests\n│ │ │ └── action.yml\n│ │ ├── post_tests_failure\n│ │ │ └── action.yml\n│ │ ├── post_tests_success\n│ │ │ └── action.yml\n│ │ ├── prepare_all_ci_images\n│ │ │ └── action.yml\n│ │ ├── prepare_breeze_and_image\n│ │ │ └── action.yml\n│ │ └── prepare_single_ci_image\n│ │ └── action.yml\n│ ├── instructions\n│ │ └── code-review.instructions.md\n│ ├── ISSUE_TEMPLATE\n│ │ ├── 1-airflow_bug_report.yml\n│ │ ├── 2-feature_request.yml\n│ │ ├── 3-free_form.yml\n│ │ ├── airflow_ctl_issue_template.yml\n│ │ └── config.yml\n│ ├── skills\n│ │ ├── aip-user-stories\n│ │ ├── airflow-translations\n│ │ ├── magpie-setup\n│ │ ├── prepare-providers-documentation\n│ │ └── upgrade-fab-provider\n│ ├── workflows\n│ │ ├── additional-ci-image-checks.yml\n│ │ ├── additional-prod-image-tests.yml\n│ │ ├── airflow-distributions-tests.yml\n│ │ ├── airflow-e2e-tests.yml\n│ │ ├── asf-allowlist-check.yml\n│ │ ├── automatic-backport.yml\n│ │ ├── backport-cli.yml\n│ │ ├── basic-tests.yml\n│ │ ├── check-newsfragment-pr-number.yml\n│ │ ├── ci-amd.yml\n│ │ ├── ci-arm.yml\n│ │ ├── ci-duration-monitor.yml\n│ │ ├── ci-image-build.yml\n│ │ ├── ci-image-checks.yml\n│ │ ├── ci-notification.yml\n│ │ ├── codeql-analysis.yml\n│ │ ├── e2e-flaky-tests-report.yml\n│ │ ├── finalize-tests.yml\n│ │ ├── generate-constraints.yml\n│ │ ├── helm-tests.yml\n│ │ ├── integration-system-tests.yml\n│ │ ├── java-sdk-release-verify.yml\n│ │ ├── k8s-tests.yml\n│ │ ├── kustomize-overlays-tests.yml\n│ │ ├── milestone-tag-assistant.yml\n│ │ ├── notify-uv-lock-conflicts.yml\n│ │ ├── openlineage-e2e-compat-tests.yml\n│ │ ├── prod-image-build.yml\n│ │ ├── prod-image-extra-checks.yml\n│ │ ├── publish-docs-to-s3.yml\n│ │ ├── push-image-cache.yml\n│ │ ├── recheck-old-bug-report.yml\n│ │ ├── registry-backfill.yml\n│ │ ├── registry-build.yml\n│ │ ├── registry-tests.yml\n│ │ ├── release_dockerhub_image.yml\n│ │ ├── release_single_dockerhub_image.yml\n│ │ ├── run-unit-tests.yml\n│ │ ├── scheduled-upgrade-check-main.yml\n│ │ ├── scheduled-verify-release-calendar.yml\n│ │ ├── special-tests.yml\n│ │ ├── stale.yml\n│ │ ├── test-providers.yml\n│ │ ├── ui-e2e-tests.yml\n│ │ ├── update-constraints-on-push-stable.yml\n│ │ ├── update-constraints-on-push.yml\n│ │ └── upgrade-check.yml\n│ ├── boring-cyborg.yml\n│ ├── CODEOWNERS\n│ ├── dependabot.yml\n│ ├── mergeable.yml\n│ ├── PULL_REQUEST_TEMPLATE.md\n│ ├── SECURITY.md\n│ └── zizmor.yml\n├── airflow-core\n│ ├── 3rd-party-licenses\n│ │ ├── LICENSE-bootstrap.txt\n│ │ ├── LICENSE-bootstrap3-typeahead.txt\n│ │ ├── LICENSE-chakra-ui.txt\n│ │ ├── LICENSE-d3-shape.txt\n│ │ ├── LICENSE-d3-tip.txt\n│ │ ├── LICENSE-d3js.txt\n│ │ ├── LICENSE-dagre-d3.txt\n│ │ ├── LICENSE-datatables.txt\n│ │ ├── LICENSE-elasticmock.txt\n│ │ ├── LICENSE-eonasdan-bootstrap-datetimepicker.txt\n│ │ ├── LICENSE-flask-kerberos.txt\n│ │ ├── LICENSE-hue.txt\n│ │ ├── LICENSE-jqclock.txt\n│ │ ├── LICENSE-jquery.txt\n│ │ ├── LICENSE-moment.txt\n│ │ ├── LICENSE-monaco-editor.txt\n│ │ ├── LICENSE-normalize.txt\n│ │ ├── LICENSE-pytest-capture-warnings.txt\n│ │ └── LICENSE-reproducible.txt\n│ ├── docs\n│ │ ├── administration-and-deployment\n│ │ │ ├── logging-monitoring\n│ │ │ │ ├── .gitignore\n│ │ │ │ ├── advanced-logging-configuration.rst\n│ │ │ │ ├── callbacks.rst\n│ │ │ │ ├── check-health.rst\n│ │ │ │ ├── errors.rst\n│ │ │ │ ├── index.rst\n│ │ │ │ ├── logging-architecture.rst\n│ │ │ │ ├── logging-tasks.rst\n│ │ │ │ ├── metrics.rst\n│ │ │ │ └── traces.rst\n│ │ │ ├── cluster-policies.rst\n│ │ │ ├── dag-bundles.rst\n│ │ │ ├── dag-serialization.rst\n│ │ │ ├── dagfile-processing.rst\n│ │ │ ├── index.rst\n│ │ │ ├── kubernetes.rst\n│ │ │ ├── lineage.rst\n│ │ │ ├── listeners.rst\n│ │ │ ├── modules_management.rst\n│ │ │ ├── plugins.rst\n│ │ │ ├── pools.rst\n│ │ │ ├── priority-weight.rst\n│ │ │ ├── production-deployment.rst\n│ │ │ ├── scheduler.rst\n│ │ │ ├── task-and-asset-state-store-cleanup.rst\n│ │ │ ├── task-and-asset-state-store.rst\n│ │ │ └── web-stack.rst\n│ │ ├── authoring-and-scheduling\n│ │ │ ├── language-sdks\n│ │ │ │ ├── go.rst\n│ │ │ │ ├── index.rst\n│ │ │ │ └── java.rst\n│ │ │ ├── asset-scheduling.rst\n│ │ │ ├── assets.rst\n│ │ │ ├── connections.rst\n│ │ │ ├── cron.rst\n│ │ │ ├── dag-result.rst\n│ │ │ ├── deferring.rst\n│ │ │ ├── dynamic-task-mapping.rst\n│ │ │ ├── event-scheduling.rst\n│ │ │ ├── index.rst\n│ │ │ ├── serializers.rst\n│ │ │ ├── timetable.rst\n│ │ │ └── timezone.rst\n│ │ ├── core-concepts\n│ │ │ ├── auth-manager\n│ │ │ │ ├── simple\n│ │ │ │ │ ├── index.rst\n│ │ │ │ │ ├── sam-token-api-ref.rst\n│ │ │ │ │ └── token.rst\n│ │ │ │ └── index.rst\n│ │ │ ├── executor\n│ │ │ │ ├── index.rst\n│ │ │ │ └── local.rst\n│ │ │ ├── asset-state-store.rst\n│ │ │ ├── backfill.rst\n│ │ │ ├── dag-run.rst\n│ │ │ ├── dags.rst\n│ │ │ ├── debug.rst\n│ │ │ ├── index.rst\n│ │ │ ├── message-queues.rst\n│ │ │ ├── multi-team.rst\n│ │ │ ├── objectstorage.rst\n│ │ │ ├── operators.rst\n│ │ │ ├── overview.rst\n│ │ │ ├── params.rst\n│ │ │ ├── resumable-tasks.rst\n│ │ │ ├── sensors.rst\n│ │ │ ├── task-and-asset-state-store.rst\n│ │ │ ├── task-state-store.rst\n│ │ │ ├── taskflow.rst\n│ │ │ ├── tasks.rst\n│ │ │ ├── variables.rst\n│ │ │ └── xcoms.rst\n│ │ ├── empty_plugin\n│ │ │ ├── templates\n│ │ │ │ └── empty_plugin\n│ │ │ │ └── index.html\n│ │ │ ├── empty_plugin.py\n│ │ │ └── README.md\n│ │ ├── howto\n│ │ │ ├── docker-compose\n│ │ │ │ ├── airflow.sh\n│ │ │ │ ├── docker-compose.yaml\n│ │ │ │ └── index.rst\n│ │ │ ├── operator\n│ │ │ │ └── index.rst\n│ │ │ ├── add-dag-tags.rst\n│ │ │ ├── add-owner-links.rst\n│ │ │ ├── connection.rst\n│ │ │ ├── create-custom-decorator.rst\n│ │ │ ├── custom-operator.rst\n│ │ │ ├── custom-view-plugin.rst\n│ │ │ ├── customize-ui.rst\n│ │ │ ├── dag-level-retry-via-callback.rst\n│ │ │ ├── deadline-alerts.rst\n│ │ │ ├── define-extra-link.rst\n│ │ │ ├── dynamic-dag-generation.rst\n│ │ │ ├── email-config.rst\n│ │ │ ├── export-more-env-vars.rst\n│ │ │ ├── index.rst\n│ │ │ ├── listener-plugin.rst\n│ │ │ ├── memory-profiling.rst\n│ │ │ ├── notifications.rst\n│ │ │ ├── performance.rst\n│ │ │ ├── run-behind-proxy.rst\n│ │ │ ├── run-with-self-signed-certificate.rst\n│ │ │ ├── run-with-systemd.rst\n│ │ │ ├── set-config.rst\n│ │ │ ├── set-up-database.rst\n│ │ │ ├── setup-and-teardown.rst\n│ │ │ ├── sla-to-deadlines.rst\n│ │ │ ├── static-type-checking.rst\n│ │ │ ├── timetable.rst\n│ │ │ ├── usage-cli.rst\n│ │ │ └── variable.rst\n│ │ ├── img\n│ │ │ ├── change-site-title\n│ │ │ │ ├── default_instance_name_configuration.png\n│ │ │ │ └── example_instance_name_configuration.png\n│ │ │ ├── change-theme\n│ │ │ │ ├── exmaple_theme_configuration_dark_mode.png\n│ │ │ │ └── exmaple_theme_configuration_light_mode.png\n│ │ │ ├── change-ui-colors\n... (16732 more entries omitted)",
"main_features": [
"Project Focus",
"Principles",
"Installing from PyPI",
"Official source code",
"Convenience packages",
"User Interface",
"Semantic versioning",
"Version Life Cycle"
],
"metadata": {
"owner": "apache",
"default_branch": "main",
"topics": [
"airflow",
"apache",
"apache-airflow",
"automation",
"dag",
"data-engineering",
"data-integration",
"data-orchestrator",
"data-pipelines",
"data-science",
"elt",
"etl",
"machine-learning",
"mlops",
"orchestration",
"python",
"scheduler",
"workflow",
"workflow-engine",
"workflow-orchestration"
]
}
}
\ No newline at end of file
{
"repo_name": "fastapi",
"repo_url": "https://github.com/fastapi/fastapi",
"stars": 100418,
"primary_language": "Python",
"updated_at": "2026-07-13T08:08:30Z",
"readme_text": "<p align=\"center\">\n <a href=\"https://fastapi.tiangolo.com\"><img src=\"https://fastapi.tiangolo.com/img/logo-margin/logo-teal.png\" alt=\"FastAPI\"></a>\n</p>\n<p align=\"center\">\n <em>FastAPI framework, high performance, easy to learn, fast to code, ready for production</em>\n</p>\n<p align=\"center\">\n<a href=\"https://github.com/fastapi/fastapi/actions?query=workflow%3ATest+event%3Apush+branch%3Amaster\">\n <img src=\"https://github.com/fastapi/fastapi/actions/workflows/test.yml/badge.svg?event=push&branch=master\" alt=\"Test\">\n</a>\n<a href=\"https://coverage-badge.samuelcolvin.workers.dev/redirect/fastapi/fastapi\">\n <img src=\"https://coverage-badge.samuelcolvin.workers.dev/fastapi/fastapi.svg\" alt=\"Coverage\">\n</a>\n<a href=\"https://pypi.org/project/fastapi\">\n <img src=\"https://img.shields.io/pypi/v/fastapi?color=%2334D058&label=pypi%20package\" alt=\"Package version\">\n</a>\n<a href=\"https://pypi.org/project/fastapi\">\n <img src=\"https://img.shields.io/pypi/pyversions/fastapi.svg?color=%2334D058\" alt=\"Supported Python versions\">\n</a>\n</p>\n\n---\n\n**Documentation**: [https://fastapi.tiangolo.com](https://fastapi.tiangolo.com)\n\n**Source Code**: [https://github.com/fastapi/fastapi](https://github.com/fastapi/fastapi)\n\n---\n\nFastAPI is a modern, fast (high-performance), web framework for building APIs with Python based on standard Python type hints.\n\nThe key features are:\n\n* **Fast**: Very high performance, on par with **NodeJS** and **Go** (thanks to Starlette and Pydantic). [One of the fastest Python frameworks available](#performance).\n* **Fast to code**: Increase the speed to develop features by about 200% to 300%. *\n* **Fewer bugs**: Reduce about 40% of human (developer) induced errors. *\n* **Intuitive**: Great editor support. <dfn title=\"also known as auto-complete, autocompletion, IntelliSense\">Completion</dfn> everywhere. Less time debugging.\n* **Easy**: Designed to be easy to use and learn. Less time reading docs.\n* **Short**: Minimize code duplication. Multiple features from each parameter declaration. Fewer bugs.\n* **Robust**: Get production-ready code. With automatic interactive documentation.\n* **Standards-based**: Based on (and fully compatible with) the open standards for APIs: [OpenAPI](https://github.com/OAI/OpenAPI-Specification) (previously known as Swagger) and [JSON Schema](https://json-schema.org/).\n\n<small>* estimation based on tests conducted by an internal development team, building production applications.</small>\n\n## Sponsors\n\n<!-- sponsors -->\n### Keystone Sponsor\n\n<a href=\"https://fastapicloud.com\" target=\"_blank\" title=\"FastAPI Cloud. By the same team behind FastAPI. You code. We Cloud.\"><img src=\"https://fastapi.tiangolo.com/img/sponsors/fastapicloud.png\"></a>\n\n### Gold Sponsors\n\n<a href=\"https://blockbee.io?ref=fastapi\" target=\"_blank\" title=\"BlockBee Cryptocurrency Payment Gateway\"><img src=\"https://fastapi.tiangolo.com/img/sponsors/blockbee.png\"></a>\n<a href=\"https://www.propelauth.com/?utm_source=fastapi&utm_campaign=1223&utm_medium=mainbadge\" target=\"_blank\" title=\"Auth, user management and more for your B2B product\"><img src=\"https://fastapi.tiangolo.com/img/sponsors/propelauth.png\"></a>\n<a href=\"https://docs.render.com/deploy-fastapi?utm_source=deploydoc&utm_medium=referral&utm_campaign=fastapi\" target=\"_blank\" title=\"Deploy & scale any full-stack web app on Render. Focus on building apps, not infra.\"><img src=\"https://fastapi.tiangolo.com/img/sponsors/render.svg\"></a>\n<a href=\"https://www.coderabbit.ai/?utm_source=fastapi&utm_medium=badge&utm_campaign=fastapi\" target=\"_blank\" title=\"Cut Code Review Time & Bugs in Half with CodeRabbit\"><img src=\"https://fastapi.tiangolo.com/img/sponsors/coderabbit.png\"></a>\n<a href=\"https://subtotal.com/?utm_source=fastapi&utm_medium=sponsorship&utm_campaign=open-source\" target=\"_blank\" title=\"The Gold Standard in Retail Account Linking\"><img src=\"https://fastapi.tiangolo.com/img/sponsors/subtotal.svg\"></a>\n<a href=\"https://docs.railway.com/guides/fastapi?utm_medium=integration&utm_source=docs&utm_campaign=fastapi\" target=\"_blank\" title=\"Deploy enterprise applications at startup speed\"><img src=\"https://fastapi.tiangolo.com/img/sponsors/railway.png\"></a>\n<a href=\"https://serpapi.com/?utm_source=fastapi_website\" target=\"_blank\" title=\"SerpApi: Web Search API\"><img src=\"https://fastapi.tiangolo.com/img/sponsors/serpapi.png\"></a>\n<a href=\"https://www.greptile.com/?utm_source=fastapi&utm_medium=sponsorship&utm_campaign=fastapi_sponsor_page\" target=\"_blank\" title=\"Greptile: The AI Code Reviewer\"><img src=\"https://fastapi.tiangolo.com/img/sponsors/greptile.png\"></a>\n\n### Silver Sponsors\n\n<a href=\"https://databento.com/?utm_source=fastapi&utm_medium=sponsor&utm_content=display\" target=\"_blank\" title=\"Pay as you go for market data\"><img src=\"https://fastapi.tiangolo.com/img/sponsors/databento.svg\"></a>\n<a href=\"https://www.svix.com/\" target=\"_blank\" title=\"Svix - Webhooks as a service\"><img src=\"https://fastapi.tiangolo.com/img/sponsors/svix.svg\"></a>\n<a href=\"https://www.permit.io/blog/implement-authorization-in-fastapi?utm_source=github&utm_medium=referral&utm_campaign=fastapi\" target=\"_blank\" title=\"Fine-Grained Authorization for FastAPI\"><img src=\"https://fastapi.tiangolo.com/img/sponsors/permit.png\"></a>\n<a href=\"https://dribia.com/en/\" target=\"_blank\" title=\"Dribia - Data Science within your reach\"><img src=\"https://fastapi.tiangolo.com/img/sponsors/dribia.png\"></a>\n<a href=\"https://www.bairesdev.com/\" target=\"_blank\" title=\"BairesDev | Nearshore Software Development & Staff Augmentation Company\"><img src=\"https://fastapi.tiangolo.com/img/sponsors/bairesdev.svg\"></a>\n<a href=\"https://tutorcruncher.com/?utm_source=fastapi\" target=\"_blank\" title=\"TutorCruncher\"><img src=\"https://fastapi.tiangolo.com/img/sponsors/tutorcruncher.png\"></a>\n\n<!-- /sponsors -->\n\n[Other sponsors](https://fastapi.tiangolo.com/fastapi-people/#sponsors)\n\n## Opinions\n\n\n\n<div class=\"only-github\" markdown=\"1\">\n\n\"_[...] I'm using **FastAPI** a ton these days. [...] I'm actually planning to use it for all of my team's **ML services at Microsoft**. Some of them are getting integrated into the core **Windows** product and some **Office** products._\"\n\n<div style=\"text-align: right; margin-right: 10%;\">Kabir Khan - <strong>Microsoft</strong> <a href=\"https://github.com/fastapi/fastapi/pull/26\"><small>(ref)</small></a></div>\n\n---\n\n\"_We adopted the **FastAPI** library to spawn a **REST** server that can be queried to obtain **predictions**. [for Ludwig]_\"\n\n<div style=\"text-align: right; margin-right: 10%;\">Piero Molino, Yaroslav Dudin, and Sai Sumanth Miryala - <strong>Uber</strong> <a href=\"https://eng.uber.com/ludwig-v0-2/\"><small>(ref)</small></a></div>\n\n---\n\n\"_**Netflix** is pleased to announce the open-source release of our **crisis management** orchestration framework: **Dispatch**! [built with **FastAPI**]_\"\n\n<div style=\"text-align: right; margin-right: 10%;\">Kevin Glisson, Marc Vilanova, Forest Monsen - <strong>Netflix</strong> <a href=\"https://netflixtechblog.com/introducing-dispatch-da4b8a2a8072\"><small>(ref)</small></a></div>\n\n---\n\n\"_If anyone is looking to build a production Python API, I would highly recommend **FastAPI**. It is **beautifully designed**, **simple to use** and **highly scalable**, it has become a **key component** in our API first development strategy and is driving many automations and services such as our Virtual TAC Engineer._\"\n\n<div style=\"text-align: right; margin-right: 10%;\">Deon Pillsbury - <strong>Cisco</strong> <a href=\"https://www.linkedin.com/posts/deonpillsbury_cisco-cx-python-activity-6963242628536487936-trAp/\"><small>(ref)</small></a></div>\n\n---\n\n</div>\n\n## FastAPI Conf\n\n[**FastAPI Conf '26**](https://fastapiconf.com) is happening on **October 28, 2026** in **Amsterdam, NL**. All about FastAPI, right from the source. 🎤\n\n<a class=\"fastapi-feature-banner\" href=\"https://fastapiconf.com\"><img src=\"https://fastapi.tiangolo.com/img/fastapi-conf.jpeg\" alt=\"FastAPI Conf '26 - October 28, 2026 - Amsterdam, NL\"></a>\n\n## FastAPI mini documentary\n\nThere's a [FastAPI mini documentary](https://www.youtube.com/watch?v=mpR8ngthqiE) released at the end of 2025, you can watch it online:\n\n<a class=\"fastapi-feature-banner\" href=\"https://www.youtube.com/watch?v=mpR8ngthqiE\"><img src=\"https://fastapi.tiangolo.com/img/fastapi-documentary.jpg\" alt=\"FastAPI Mini Documentary\"></a>\n\n## **Typer**, the FastAPI of CLIs\n\n<a href=\"https://typer.tiangolo.com\"><img src=\"https://typer.tiangolo.com/img/logo-margin/logo-margin-vector.svg\" style=\"width: 20%;\"></a>\n\nIf you are building a <abbr title=\"Command Line Interface\">CLI</abbr> app to be used in the terminal instead of a web API, check out [**Typer**](https://typer.tiangolo.com/).\n\n**Typer** is FastAPI's little sibling. And it's intended to be the **FastAPI of CLIs**. ⌨️ 🚀\n\n## Requirements\n\nFastAPI stands on the shoulders of giants:\n\n* [Starlette](https://www.starlette.dev/) for the web parts.\n* [Pydantic](https://docs.pydantic.dev/) for the data parts.\n\n## Installation\n\nCreate and activate a [virtual environment](https://fastapi.tiangolo.com/virtual-environments/) and then install FastAPI:\n\n<div class=\"termy\">\n\n```console\n$ pip install \"fastapi[standard]\"\n\n---> 100%\n```\n\n</div>\n\n**Note**: Make sure you put `\"fastapi[standard]\"` in quotes to ensure it works in all terminals.\n\n## Example\n\n### Create it\n\nCreate a file `main.py` with:\n\n```Python\nfrom fastapi import FastAPI\n\napp = FastAPI()\n\n\n@app.get(\"/\")\ndef read_root():\n return {\"Hello\": \"World\"}\n\n\n@app.get(\"/items/{item_id}\")\ndef read_item(item_id: int, q: str | None = None):\n return {\"item_id\": item_id, \"q\": q}\n```\n\n<details markdown=\"1\">\n<summary>Or use <code>async def</code>...</summary>\n\nIf your code uses `async` / `await`, use `async def`:\n\n```Python hl_lines=\"7 12\"\nfrom fastapi import FastAPI\n\napp = FastAPI()\n\n\n@app.get(\"/\")\nasync def read_root():\n return {\"Hello\": \"World\"}\n\n\n@app.get(\"/items/{item_id}\")\nasync def read_item(item_id: int, q: str | None = None):\n return {\"item_id\": item_id, \"q\": q}\n```\n\n**Note**:\n\nIf you don't know, check the _\"In a hurry?\"_ section about [`async` and `await` in the docs](https://fastapi.tiangolo.com/async/#in-a-hurry).\n\n</details>\n\n### Run it\n\nRun the server with:\n\n<div class=\"termy\">\n\n```console\n$ fastapi dev\n\n ╭────────── FastAPI CLI - Development mode ───────────╮\n │ │\n │ Serving at: http://127.0.0.1:8000 │\n │ │\n │ API docs: http://127.0.0.1:8000/docs │\n │ │\n │ Running in development mode, for production use: │\n │ │\n │ fastapi run │\n │ │\n ╰─────────────────────────────────────────────────────╯\n\nINFO: Will watch for changes in these directories: ['/home/user/code/awesomeapp']\nINFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)\nINFO: Started reloader process [2248755] using WatchFiles\nINFO: Started server process [2248757]\nINFO: Waiting for application startup.\nINFO: Application startup complete.\n```\n\n</div>\n\n<details markdown=\"1\">\n<summary>About the command <code>fastapi dev</code>...</summary>\n\nThe command `fastapi dev` reads your `main.py` file automatically, detects the **FastAPI** app in it, and starts a server using [Uvicorn](https://www.uvicorn.dev).\n\nBy default, `fastapi dev` will start with auto-reload enabled for local development.\n\nYou can read more about it in the [FastAPI CLI docs](https://fastapi.tiangolo.com/fastapi-cli/).\n\n</details>\n\n### Check it\n\nOpen your browser at [http://127.0.0.1:8000/items/5?q=somequery](http://127.0.0.1:8000/items/5?q=somequery).\n\nYou will see the JSON response as:\n\n```JSON\n{\"item_id\": 5, \"q\": \"somequery\"}\n```\n\nYou already created an API that:\n\n* Receives HTTP requests in the _paths_ `/` and `/items/{item_id}`.\n* Both _paths_ take `GET` <em>operations</em> (also known as HTTP _methods_).\n* The _path_ `/items/{item_id}` has a _path parameter_ `item_id` that should be an `int`.\n* The _path_ `/items/{item_id}` has an optional `str` _query parameter_ `q`.\n\n### Interactive API docs\n\nNow go to [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).\n\nYou will see the automatic interactive API documentation (provided by [Swagger UI](https://github.com/swagger-api/swagger-ui)):\n\n![Swagger UI](https://fastapi.tiangolo.com/img/index/index-01-swagger-ui-simple.png)\n\n### Alternative API docs\n\nAnd now, go to [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc).\n\nYou will see the alternative automatic documentation (provided by [ReDoc](https://github.com/Rebilly/ReDoc)):\n\n![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png)\n\n## Example upgrade\n\nNow modify the file `main.py` to receive a body from a `PUT` request.\n\nDeclare the body using standard Python types, thanks to Pydantic.\n\n```Python hl_lines=\"2 7-10 23-25\"\nfrom fastapi import FastAPI\nfrom pydantic import BaseModel\n\napp = FastAPI()\n\n\nclass Item(BaseModel):\n name: str\n price: float\n is_offer: bool | None = None\n\n\n@app.get(\"/\")\ndef read_root():\n return {\"Hello\": \"World\"}\n\n\n@app.get(\"/items/{item_id}\")\ndef read_item(item_id: int, q: str | None = None):\n return {\"item_id\": item_id, \"q\": q}\n\n\n@app.put(\"/items/{item_id}\")\ndef update_item(item_id: int, item: Item):\n return {\"item_name\": item.name, \"item_id\": item_id}\n```\n\nThe `fastapi dev` server should reload automatically.\n\n### Interactive API docs upgrade\n\nNow go to [http://127.0.0.1:8000/docs](http://127.0.0.1:8000/docs).\n\n* The interactive API documentation will be automatically updated, including the new body:\n\n![Swagger UI](https://fastapi.tiangolo.com/img/index/index-03-swagger-02.png)\n\n* Click on the button \"Try it out\", it allows you to fill the parameters and directly interact with the API:\n\n![Swagger UI interaction](https://fastapi.tiangolo.com/img/index/index-04-swagger-03.png)\n\n* Then click on the \"Execute\" button, the user interface will communicate with your API, send the parameters, get the results and show them on the screen:\n\n![Swagger UI interaction](https://fastapi.tiangolo.com/img/index/index-05-swagger-04.png)\n\n### Alternative API docs upgrade\n\nAnd now, go to [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc).\n\n* The alternative documentation will also reflect the new query parameter and body:\n\n![ReDoc](https://fastapi.tiangolo.com/img/index/index-06-redoc-02.png)\n\n### Recap\n\nIn summary, you declare **once** the types of parameters, body, etc. as function parameters.\n\nYou do that with standard modern Python types.\n\nYou don't have to learn a new syntax, the methods or classes of a specific library, etc.\n\nJust standard **Python**.\n\nFor example, for an `int`:\n\n```Python\nitem_id: int\n```\n\nor for a more complex `Item` model:\n\n```Python\nitem: Item\n```\n\n...and with that single declaration you get:\n\n* Editor support, including:\n * Completion.\n * Type checks.\n* Validation of data:\n * Automatic and clear errors when the data is invalid.\n * Validation even for deeply nested JSON objects.\n* <dfn title=\"also known as: serialization, parsing, marshalling\">Conversion</dfn> of input data: coming from the network to Python data and types. Reading from:\n * JSON.\n * Path parameters.\n * Query parameters.\n * Cookies.\n * Headers.\n * Forms.\n * Files.\n* <dfn title=\"also known as: serialization, parsing, marshalling\">Conversion</dfn> of output data: converting from Python data and types to network data (as JSON):\n * Convert Python types (`str`, `int`, `float`, `bool`, `list`, etc).\n * `datetime` objects.\n * `UUID` objects.\n * Database models.\n * ...and many more.\n* Automatic interactive API documentation, including 2 alternative user interfaces:\n * Swagger UI.\n * ReDoc.\n\n---\n\nComing back to the previous code example, **FastAPI** will:\n\n* Validate that there is an `item_id` in the path for `GET` and `PUT` requests.\n* Validate that the `item_id` is of type `int` for `GET` and `PUT` requests.\n * If it is not, the client will see a useful, clear error.\n* Check if there is an optional query parameter named `q` (as in `http://127.0.0.1:8000/items/foo?q=somequery`) for `GET` requests.\n * As the `q` parameter is declared with `= None`, it is optional.\n * Without the `None` it would be required (as is the body in the case with `PUT`).\n* For `PUT` requests to `/items/{item_id}`, read the body as JSON:\n * Check that it has a required attribute `name` that should be a `str`.\n * Check that it has a required attribute `price` that has to be a `float`.\n * Check that it has an optional attribute `is_offer`, that should be a `bool`, if present.\n * All this would also work for deeply nested JSON objects.\n* Convert from and to JSON automatically.\n* Document everything with OpenAPI, that can be used by:\n * Interactive documentation systems.\n * Automatic client code generation systems, for many languages.\n* Provide 2 interactive documentation web interfaces directly.\n\n---\n\nWe just scratched the surface, but you already get the idea of how it all works.\n\nTry changing the line with:\n\n```Python\n return {\"item_name\": item.name, \"item_id\": item_id}\n```\n\n...from:\n\n```Python\n ... \"item_name\": item.name ...\n```\n\n...to:\n\n```Python\n ... \"item_price\": item.price ...\n```\n\n...and see how your editor will auto-complete the attributes and know their types:\n\n![editor support](https://fastapi.tiangolo.com/img/vscode-completion.png)\n\nFor a more complete example including more features, see the <a href=\"https://fastapi.tiangolo.com/tutorial/\">Tutorial - User Guide</a>.\n\n**Spoiler alert**: the tutorial - user guide includes:\n\n* Declaration of **parameters** from other different places such as: **headers**, **cookies**, **form fields** and **files**.\n* How to set **validation constraints** such as `maximum_length` or `regex`.\n* A very powerful and easy to use **<dfn title=\"also known as components, resources, providers, services, injectables\">Dependency Injection</dfn>** system.\n* Security and authentication, including support for **OAuth2** with **JWT tokens** and **HTTP Basic** auth.\n* More advanced (but equally easy) techniques for declaring **deeply nested JSON models** (thanks to Pydantic).\n* **GraphQL** integration with [Strawberry](https://strawberry.rocks) and other libraries.\n* Many extra features (thanks to Starlette) such as:\n * **WebSockets**\n * extremely easy tests based on HTTPX and `pytest`\n * **CORS**\n * **Cookie Sessions**\n * ...and more.\n\n### Deploy your app (optional)\n\nYou can optionally deploy your FastAPI app to [FastAPI Cloud](https://fastapicloud.com) with a single command. 🚀\n\n<div class=\"termy\">\n\n```console\n$ fastapi deploy\n\nDeploying to FastAPI Cloud...\n\n✅ Deployment successful!\n\n🐔 Ready the chicken! Your app is ready at https://myapp.fastapicloud.dev\n```\n\n</div>\n\nThe CLI will automatically detect your FastAPI application and deploy it to the cloud. If you are not logged in, your browser will open to complete the authentication process.\n\nThat's it! Now you can access your app at that URL. ✨\n\n#### About FastAPI Cloud\n\n**[FastAPI Cloud](https://fastapicloud.com)** is built by the same author and team behind **FastAPI**.\n\nIt streamlines the process of **building**, **deploying**, and **accessing** an API with minimal effort.\n\nIt brings the same **developer experience** of building apps with FastAPI to **deploying** them to the cloud. 🎉\n\nFastAPI Cloud is the primary sponsor and funding provider for the *FastAPI and friends* open source projects. ✨\n\n#### Deploy to other cloud providers\n\nFastAPI is open source and based on standards. You can deploy FastAPI apps to any cloud provider you choose.\n\nFollow your cloud provider's guides to deploy FastAPI apps with them. 🤓\n\n## Performance\n\nIndependent TechEmpower benchmarks show **FastAPI** applications running under Uvicorn as [one of the fastest Python frameworks available](https://www.techempower.com/benchmarks/#section=test&runid=7464e520-0dc2-473d-bd34-dbdfd7e85911&hw=ph&test=query&l=zijzen-7), only below Starlette and Uvicorn themselves (used internally by FastAPI). (*)\n\nTo understand more about it, see the section [Benchmarks](https://fastapi.tiangolo.com/benchmarks/).\n\n## Dependencies\n\nFastAPI depends on Pydantic and Starlette.\n\n### `standard` Dependencies\n\nWhen you install FastAPI with `pip install \"fastapi[standard]\"` it comes with the `standard` group of optional dependencies:\n\nUsed by Pydantic:\n\n* [`email-validator`](https://github.com/JoshData/python-email-validator) - for email validation.\n\nUsed by Starlette:\n\n* [`httpx`](https://www.python-httpx.org) - Required if you want to use the `TestClient`.\n* [`jinja2`](https://jinja.palletsprojects.com) - Required if you want to use the default template configuration.\n* [`python-multipart`](https://github.com/Kludex/python-multipart) - Required if you want to support form <dfn title=\"converting the string that comes from an HTTP request into Python data\">\"parsing\"</dfn>, with `request.form()`.\n\nUsed by FastAPI:\n\n* [`uvicorn`](https://www.uvicorn.dev) - for the server that loads and serves your application. This includes `uvicorn[standard]`, which includes some dependencies (e.g. `uvloop`) needed for high performance serving.\n* `fastapi-cli[standard]` - to provide the `fastapi` command.\n * This includes `fastapi-cloud-cli`, which allows you to deploy your FastAPI application to [FastAPI Cloud](https://fastapicloud.com).\n\n### Without `standard` Dependencies\n\nIf you don't want to include the `standard` optional dependencies, you can install with `pip install fastapi` instead of `pip install \"fastapi[standard]\"`.\n\n### Without `fastapi-cloud-cli`\n\nIf you want to install FastAPI with the standard dependencies but without the `fastapi-cloud-cli`, you can install with `pip install \"fastapi[standard-no-fastapi-cloud-cli]\"`.\n\n### Additional Optional Dependencies\n\nThere are some additional dependencies you might want to install.\n\nAdditional optional Pydantic dependencies:\n\n* [`pydantic-settings`](https://docs.pydantic.dev/latest/usage/pydantic_settings/) - for settings management.\n* [`pydantic-extra-types`](https://docs.pydantic.dev/latest/usage/types/extra_types/extra_types/) - for extra types to be used with Pydantic.\n\nAdditional optional FastAPI dependencies:\n\n* [`orjson`](https://github.com/ijl/orjson) - Required if you want to use `ORJSONResponse`.\n* [`ujson`](https://github.com/esnme/ultrajson) - Required if you want to use `UJSONResponse`.\n\n## License\n\nThis project is licensed under the terms of the MIT license.",
"directory_tree": "├── .github\n│ ├── DISCUSSION_TEMPLATE\n│ │ ├── questions.yml\n│ │ └── translations.yml\n│ ├── ISSUE_TEMPLATE\n│ │ ├── config.yml\n│ │ └── privileged.yml\n│ ├── workflows\n│ │ ├── add-to-project.yml\n│ │ ├── build-docs.yml\n│ │ ├── bump-pre-commit-hooks.yml\n│ │ ├── contributors.yml\n│ │ ├── create-draft-release.yml\n│ │ ├── deploy-docs.yml\n│ │ ├── detect-conflicts.yml\n│ │ ├── guard-dependencies.yml\n│ │ ├── issue-manager.yml\n│ │ ├── label-approved.yml\n│ │ ├── labeler.yml\n│ │ ├── latest-changes.yml\n│ │ ├── notify-translations.yml\n│ │ ├── people.yml\n│ │ ├── pre-commit.yml\n│ │ ├── prepare-release.yml\n│ │ ├── publish.yml\n│ │ ├── smokeshow.yml\n│ │ ├── sponsors.yml\n│ │ ├── test-redistribute.yml\n│ │ ├── test.yml\n│ │ ├── topic-repos.yml\n│ │ ├── translate.yml\n│ │ └── zizmor.yml\n│ ├── dependabot.yml\n│ └── labeler.yml\n├── docs\n│ ├── de\n│ │ ├── docs\n│ │ │ ├── about\n│ │ │ │ └── index.md\n│ │ │ ├── advanced\n│ │ │ │ ├── security\n│ │ │ │ │ ├── http-basic-auth.md\n│ │ │ │ │ ├── index.md\n│ │ │ │ │ └── oauth2-scopes.md\n│ │ │ │ ├── additional-responses.md\n│ │ │ │ ├── additional-status-codes.md\n│ │ │ │ ├── advanced-dependencies.md\n│ │ │ │ ├── advanced-python-types.md\n│ │ │ │ ├── async-tests.md\n│ │ │ │ ├── behind-a-proxy.md\n│ │ │ │ ├── custom-response.md\n│ │ │ │ ├── dataclasses.md\n│ │ │ │ ├── events.md\n│ │ │ │ ├── generate-clients.md\n│ │ │ │ ├── index.md\n│ │ │ │ ├── json-base64-bytes.md\n│ │ │ │ ├── middleware.md\n│ │ │ │ ├── openapi-callbacks.md\n│ │ │ │ ├── openapi-webhooks.md\n│ │ │ │ ├── path-operation-advanced-configuration.md\n│ │ │ │ ├── response-change-status-code.md\n│ │ │ │ ├── response-cookies.md\n│ │ │ │ ├── response-directly.md\n│ │ │ │ ├── response-headers.md\n│ │ │ │ ├── settings.md\n│ │ │ │ ├── stream-data.md\n│ │ │ │ ├── strict-content-type.md\n│ │ │ │ ├── sub-applications.md\n│ │ │ │ ├── templates.md\n│ │ │ │ ├── testing-dependencies.md\n│ │ │ │ ├── testing-events.md\n│ │ │ │ ├── testing-websockets.md\n│ │ │ │ ├── using-request-directly.md\n│ │ │ │ ├── websockets.md\n│ │ │ │ └── wsgi.md\n│ │ │ ├── deployment\n│ │ │ │ ├── cloud.md\n│ │ │ │ ├── concepts.md\n│ │ │ │ ├── docker.md\n│ │ │ │ ├── fastapicloud.md\n│ │ │ │ ├── https.md\n│ │ │ │ ├── index.md\n│ │ │ │ ├── manually.md\n│ │ │ │ ├── server-workers.md\n│ │ │ │ └── versions.md\n│ │ │ ├── how-to\n│ │ │ │ ├── authentication-error-status-code.md\n│ │ │ │ ├── conditional-openapi.md\n│ │ │ │ ├── configure-swagger-ui.md\n│ │ │ │ ├── custom-docs-ui-assets.md\n│ │ │ │ ├── custom-request-and-route.md\n│ │ │ │ ├── extending-openapi.md\n│ │ │ │ ├── general.md\n│ │ │ │ ├── graphql.md\n│ │ │ │ ├── index.md\n│ │ │ │ ├── migrate-from-pydantic-v1-to-pydantic-v2.md\n│ │ │ │ ├── separate-openapi-schemas.md\n│ │ │ │ └── testing-database.md\n│ │ │ ├── learn\n│ │ │ │ └── index.md\n│ │ │ ├── resources\n│ │ │ │ └── index.md\n│ │ │ ├── tutorial\n│ │ │ │ ├── dependencies\n│ │ │ │ │ ├── classes-as-dependencies.md\n│ │ │ │ │ ├── dependencies-in-path-operation-decorators.md\n│ │ │ │ │ ├── dependencies-with-yield.md\n│ │ │ │ │ ├── global-dependencies.md\n│ │ │ │ │ ├── index.md\n│ │ │ │ │ └── sub-dependencies.md\n│ │ │ │ ├── security\n│ │ │ │ │ ├── first-steps.md\n│ │ │ │ │ ├── get-current-user.md\n│ │ │ │ │ ├── index.md\n│ │ │ │ │ ├── oauth2-jwt.md\n│ │ │ │ │ └── simple-oauth2.md\n│ │ │ │ ├── background-tasks.md\n│ │ │ │ ├── bigger-applications.md\n│ │ │ │ ├── body-fields.md\n│ │ │ │ ├── body-multiple-params.md\n│ │ │ │ ├── body-nested-models.md\n│ │ │ │ ├── body-updates.md\n│ │ │ │ ├── body.md\n│ │ │ │ ├── cookie-param-models.md\n│ │ │ │ ├── cookie-params.md\n│ │ │ │ ├── cors.md\n│ │ │ │ ├── debugging.md\n│ │ │ │ ├── encoder.md\n│ │ │ │ ├── extra-data-types.md\n│ │ │ │ ├── extra-models.md\n│ │ │ │ ├── first-steps.md\n│ │ │ │ ├── frontend.md\n│ │ │ │ ├── handling-errors.md\n│ │ │ │ ├── header-param-models.md\n│ │ │ │ ├── header-params.md\n│ │ │ │ ├── index.md\n│ │ │ │ ├── metadata.md\n│ │ │ │ ├── middleware.md\n│ │ │ │ ├── path-operation-configuration.md\n│ │ │ │ ├── path-params-numeric-validations.md\n│ │ │ │ ├── path-params.md\n│ │ │ │ ├── query-param-models.md\n│ │ │ │ ├── query-params-str-validations.md\n│ │ │ │ ├── query-params.md\n│ │ │ │ ├── request-files.md\n│ │ │ │ ├── request-form-models.md\n│ │ │ │ ├── request-forms-and-files.md\n│ │ │ │ ├── request-forms.md\n│ │ │ │ ├── response-model.md\n│ │ │ │ ├── response-status-code.md\n│ │ │ │ ├── schema-extra-example.md\n│ │ │ │ ├── server-sent-events.md\n│ │ │ │ ├── sql-databases.md\n│ │ │ │ ├── static-files.md\n│ │ │ │ ├── stream-json-lines.md\n│ │ │ │ └── testing.md\n│ │ │ ├── _llm-test.md\n│ │ │ ├── alternatives.md\n│ │ │ ├── async.md\n│ │ │ ├── benchmarks.md\n│ │ │ ├── editor-support.md\n│ │ │ ├── environment-variables.md\n│ │ │ ├── fastapi-cli.md\n│ │ │ ├── features.md\n│ │ │ ├── help-fastapi.md\n│ │ │ ├── history-design-future.md\n│ │ │ ├── index.md\n│ │ │ ├── project-generation.md\n│ │ │ ├── python-types.md\n│ │ │ ├── translation-banner.md\n│ │ │ └── virtual-environments.md\n│ │ └── llm-prompt.md\n│ ├── en\n│ │ ├── data\n│ │ │ ├── contributors.yml\n│ │ │ ├── github_sponsors.yml\n│ │ │ ├── members.yml\n│ │ │ ├── people.yml\n│ │ │ ├── skip_users.yml\n│ │ │ ├── sponsors.yml\n│ │ │ ├── sponsors_badge.yml\n│ │ │ ├── topic_repos.yml\n│ │ │ ├── translation_reviewers.yml\n│ │ │ └── translators.yml\n│ │ ├── docs\n│ │ │ ├── about\n│ │ │ │ └── index.md\n│ │ │ ├── advanced\n│ │ │ │ ├── security\n│ │ │ │ │ ├── http-basic-auth.md\n│ │ │ │ │ ├── index.md\n│ │ │ │ │ └── oauth2-scopes.md\n│ │ │ │ ├── additional-responses.md\n│ │ │ │ ├── additional-status-codes.md\n│ │ │ │ ├── advanced-dependencies.md\n│ │ │ │ ├── advanced-python-types.md\n│ │ │ │ ├── async-tests.md\n│ │ │ │ ├── behind-a-proxy.md\n│ │ │ │ ├── custom-response.md\n│ │ │ │ ├── dataclasses.md\n│ │ │ │ ├── events.md\n│ │ │ │ ├── generate-clients.md\n│ │ │ │ ├── index.md\n│ │ │ │ ├── json-base64-bytes.md\n│ │ │ │ ├── middleware.md\n│ │ │ │ ├── openapi-callbacks.md\n│ │ │ │ ├── openapi-webhooks.md\n│ │ │ │ ├── path-operation-advanced-configuration.md\n│ │ │ │ ├── response-change-status-code.md\n│ │ │ │ ├── response-cookies.md\n│ │ │ │ ├── response-directly.md\n│ │ │ │ ├── response-headers.md\n│ │ │ │ ├── settings.md\n│ │ │ │ ├── stream-data.md\n│ │ │ │ ├── strict-content-type.md\n│ │ │ │ ├── sub-applications.md\n│ │ │ │ ├── templates.md\n│ │ │ │ ├── testing-dependencies.md\n│ │ │ │ ├── testing-events.md\n│ │ │ │ ├── testing-websockets.md\n│ │ │ │ ├── using-request-directly.md\n│ │ │ │ ├── websockets.md\n│ │ │ │ └── wsgi.md\n│ │ │ ├── css\n│ │ │ │ ├── custom.css\n│ │ │ │ └── termynal.css\n│ │ │ ├── deployment\n│ │ │ │ ├── cloud.md\n│ │ │ │ ├── concepts.md\n│ │ │ │ ├── docker.md\n│ │ │ │ ├── fastapicloud.md\n│ │ │ │ ├── https.md\n│ │ │ │ ├── index.md\n│ │ │ │ ├── manually.md\n│ │ │ │ ├── server-workers.md\n│ │ │ │ └── versions.md\n│ │ │ ├── how-to\n│ │ │ │ ├── authentication-error-status-code.md\n│ │ │ │ ├── conditional-openapi.md\n│ │ │ │ ├── configure-swagger-ui.md\n│ │ │ │ ├── custom-docs-ui-assets.md\n│ │ │ │ ├── custom-request-and-route.md\n│ │ │ │ ├── extending-openapi.md\n│ │ │ │ ├── general.md\n│ │ │ │ ├── graphql.md\n│ │ │ │ ├── index.md\n│ │ │ │ ├── migrate-from-pydantic-v1-to-pydantic-v2.md\n│ │ │ │ ├── separate-openapi-schemas.md\n│ │ │ │ └── testing-database.md\n│ │ │ ├── img\n│ │ │ │ ├── async\n│ │ │ │ │ ├── concurrent-burgers\n│ │ │ │ │ │ ├── concurrent-burgers-01.png\n│ │ │ │ │ │ ├── concurrent-burgers-02.png\n│ │ │ │ │ │ ├── concurrent-burgers-03.png\n│ │ │ │ │ │ ├── concurrent-burgers-04.png\n│ │ │ │ │ │ ├── concurrent-burgers-05.png\n│ │ │ │ │ │ ├── concurrent-burgers-06.png\n│ │ │ │ │ │ └── concurrent-burgers-07.png\n│ │ │ │ │ └── parallel-burgers\n│ │ │ │ │ ├── parallel-burgers-01.png\n│ │ │ │ │ ├── parallel-burgers-02.png\n│ │ │ │ │ ├── parallel-burgers-03.png\n│ │ │ │ │ ├── parallel-burgers-04.png\n│ │ │ │ │ ├── parallel-burgers-05.png\n│ │ │ │ │ └── parallel-burgers-06.png\n│ │ │ │ ├── deployment\n│ │ │ │ │ ├── concepts\n│ │ │ │ │ │ ├── image01.png\n│ │ │ │ │ │ └── process-ram.drawio.svg\n│ │ │ │ │ ├── deta\n│ │ │ │ │ │ ├── image01.png\n│ │ │ │ │ │ ├── image02.png\n│ │ │ │ │ │ ├── image03.png\n│ │ │ │ │ │ ├── image04.png\n│ │ │ │ │ │ ├── image05.png\n│ │ │ │ │ │ └── image06.png\n│ │ │ │ │ └── https\n│ │ │ │ │ ├── https.drawio.svg\n│ │ │ │ │ ├── https01.drawio.svg\n│ │ │ │ │ ├── https02.drawio.svg\n│ │ │ │ │ ├── https03.drawio.svg\n│ │ │ │ │ ├── https04.drawio.svg\n│ │ │ │ │ ├── https05.drawio.svg\n│ │ │ │ │ ├── https06.drawio.svg\n│ │ │ │ │ ├── https07.drawio.svg\n│ │ │ │ │ └── https08.drawio.svg\n│ │ │ │ ├── index\n│ │ │ │ │ ├── index-01-swagger-ui-simple.png\n│ │ │ │ │ ├── index-02-redoc-simple.png\n│ │ │ │ │ ├── index-03-swagger-02.png\n│ │ │ │ │ ├── index-04-swagger-03.png\n│ │ │ │ │ ├── index-05-swagger-04.png\n│ │ │ │ │ └── index-06-redoc-02.png\n│ │ │ │ ├── logo-margin\n│ │ │ │ │ ├── logo-teal-vector.svg\n│ │ │ │ │ ├── logo-teal.png\n│ │ │ │ │ ├── logo-teal.svg\n│ │ │ │ │ └── logo-white-bg.png\n│ │ │ │ ├── logos\n... (3140 more entries omitted)",
"main_features": [
"Fast: Very high performance, on par with NodeJS and Go (thanks to Starlette and Pydantic). One of the fastest Python frameworks available",
"Fast to code: Increase the speed to develop features by about 200% to 300%",
"Fewer bugs: Reduce about 40% of human (developer) induced errors",
"Intuitive: Great editor support. Completion everywhere. Less time debugging",
"Easy: Designed to be easy to use and learn. Less time reading docs",
"Short: Minimize code duplication. Multiple features from each parameter declaration. Fewer bugs",
"Robust: Get production-ready code. With automatic interactive documentation",
"Standards-based: Based on (and fully compatible with) the open standards for APIs: OpenAPI (previously known as Swagger) and JSON Schema"
],
"metadata": {
"owner": "fastapi",
"default_branch": "master",
"topics": [
"api",
"async",
"asyncio",
"fastapi",
"framework",
"json",
"json-schema",
"openapi",
"openapi3",
"pydantic",
"python",
"python-types",
"python3",
"redoc",
"rest",
"starlette",
"swagger",
"swagger-ui",
"uvicorn",
"web"
]
}
}
\ No newline at end of file
{
"repo_name": "transformers",
"repo_url": "https://github.com/huggingface/transformers",
"stars": 162559,
"primary_language": "Python",
"updated_at": "2026-07-13T07:42:55Z",
"readme_text": "<!---\nCopyright 2020 The HuggingFace Team. All rights reserved.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n-->\n\n<p align=\"center\">\n <picture>\n <source media=\"(prefers-color-scheme: dark)\" srcset=\"https://huggingface.co/datasets/huggingface/documentation-images/raw/main/transformers-logo-dark.svg\">\n <source media=\"(prefers-color-scheme: light)\" srcset=\"https://huggingface.co/datasets/huggingface/documentation-images/raw/main/transformers-logo-light.svg\">\n <img alt=\"Hugging Face Transformers Library\" src=\"https://huggingface.co/datasets/huggingface/documentation-images/raw/main/transformers-logo-light.svg\" width=\"352\" height=\"59\" style=\"max-width: 100%;\">\n </picture>\n <br/>\n <br/>\n</p>\n\n<p align=\"center\">\n <a href=\"https://huggingface.com/models\"><img alt=\"Checkpoints on Hub\" src=\"https://img.shields.io/endpoint?url=https://huggingface.co/api/shields/models&color=brightgreen\"></a>\n <a href=\"https://circleci.com/gh/huggingface/transformers\"><img alt=\"Build\" src=\"https://img.shields.io/circleci/build/github/huggingface/transformers/main\"></a>\n <a href=\"https://github.com/huggingface/transformers/blob/main/LICENSE\"><img alt=\"GitHub\" src=\"https://img.shields.io/github/license/huggingface/transformers.svg?color=blue\"></a>\n <a href=\"https://huggingface.co/docs/transformers/index\"><img alt=\"Documentation\" src=\"https://img.shields.io/website/http/huggingface.co/docs/transformers/index.svg?down_color=red&down_message=offline&up_message=online\"></a>\n <a href=\"https://github.com/huggingface/transformers/releases\"><img alt=\"GitHub release\" src=\"https://img.shields.io/github/release/huggingface/transformers.svg\"></a>\n <a href=\"https://github.com/huggingface/transformers/blob/main/CODE_OF_CONDUCT.md\"><img alt=\"Contributor Covenant\" src=\"https://img.shields.io/badge/Contributor%20Covenant-v2.0%20adopted-ff69b4.svg\"></a>\n <a href=\"https://zenodo.org/badge/latestdoi/155220641\"><img src=\"https://zenodo.org/badge/155220641.svg\" alt=\"DOI\"></a>\n</p>\n\n<h4 align=\"center\">\n <p>\n <b>English</b> |\n <a href=\"https://github.com/huggingface/transformers/blob/main/i18n/README_zh-hans.md\">简体中文</a> |\n <a href=\"https://github.com/huggingface/transformers/blob/main/i18n/README_zh-hant.md\">繁體中文</a> |\n <a href=\"https://github.com/huggingface/transformers/blob/main/i18n/README_ko.md\">한국어</a> |\n <a href=\"https://github.com/huggingface/transformers/blob/main/i18n/README_es.md\">Español</a> |\n <a href=\"https://github.com/huggingface/transformers/blob/main/i18n/README_ja.md\">日本語</a> |\n <a href=\"https://github.com/huggingface/transformers/blob/main/i18n/README_hd.md\">हिन्दी</a> |\n <a href=\"https://github.com/huggingface/transformers/blob/main/i18n/README_ru.md\">Русский</a> |\n <a href=\"https://github.com/huggingface/transformers/blob/main/i18n/README_pt-br.md\">Português</a> |\n <a href=\"https://github.com/huggingface/transformers/blob/main/i18n/README_te.md\">తెలుగు</a> |\n <a href=\"https://github.com/huggingface/transformers/blob/main/i18n/README_fr.md\">Français</a> |\n <a href=\"https://github.com/huggingface/transformers/blob/main/i18n/README_de.md\">Deutsch</a> |\n <a href=\"https://github.com/huggingface/transformers/blob/main/i18n/README_it.md\">Italiano</a> |\n <a href=\"https://github.com/huggingface/transformers/blob/main/i18n/README_vi.md\">Tiếng Việt</a> |\n <a href=\"https://github.com/huggingface/transformers/blob/main/i18n/README_ar.md\">العربية</a> |\n <a href=\"https://github.com/huggingface/transformers/blob/main/i18n/README_ur.md\">اردو</a> |\n <a href=\"https://github.com/huggingface/transformers/blob/main/i18n/README_bn.md\">বাংলা</a> |\n <a href=\"https://github.com/huggingface/transformers/blob/main/i18n/README_fa.md\">فارسی</a> |\n <a href=\"https://github.com/huggingface/transformers/blob/main/i18n/README_tr.md\">Türkçe</a> |\n </p>\n</h4>\n\n<h3 align=\"center\">\n <p>State-of-the-art pretrained models for inference and training</p>\n</h3>\n\n<h3 align=\"center\">\n <img src=\"https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/transformers_as_a_model_definition.png\"/>\n</h3>\n\nTransformers acts as the model-definition framework for state-of-the-art machine learning with text, computer\nvision, audio, video, and multimodal models, for both inference and training.\n\nIt centralizes the model definition so that this definition is agreed upon across the ecosystem. `transformers` is the\npivot across frameworks: if a model definition is supported, it will be compatible with the majority of training\nframeworks (Axolotl, Unsloth, DeepSpeed, FSDP, PyTorch-Lightning, ...), inference engines (vLLM, SGLang, TGI, ...),\nand adjacent modeling libraries (llama.cpp, mlx, ...) which leverage the model definition from `transformers`.\n\nWe pledge to help support new state-of-the-art models and democratize their usage by having their model definition be\nsimple, customizable, and efficient.\n\nThere are over 1M+ Transformers [model checkpoints](https://huggingface.co/models?library=transformers&sort=trending) on the [Hugging Face Hub](https://huggingface.co/models) you can use.\n\nExplore the [Hub](https://huggingface.co/) today to find a model and use Transformers to help you get started right away.\n\n## Installation\n\nTransformers works with Python 3.10+, and [PyTorch](https://pytorch.org/get-started/locally/) 2.4+.\n\nCreate and activate a virtual environment with [venv](https://docs.python.org/3/library/venv.html) or [uv](https://docs.astral.sh/uv/), a fast Rust-based Python package and project manager.\n\n```py\n# venv\npython -m venv .my-env\nsource .my-env/bin/activate\n# uv\nuv venv .my-env\nsource .my-env/bin/activate\n```\n\nInstall Transformers in your virtual environment.\n\n```py\n# pip\npip install \"transformers[torch]\"\n\n# uv\nuv pip install \"transformers[torch]\"\n```\n\nInstall Transformers from source if you want the latest changes in the library or are interested in contributing. However, the *latest* version may not be stable. Feel free to open an [issue](https://github.com/huggingface/transformers/issues) if you encounter an error.\n\n```shell\ngit clone https://github.com/huggingface/transformers.git\ncd transformers\n\n# pip\npip install '.[torch]'\n\n# uv\nuv pip install '.[torch]'\n```\n\n## Quickstart\n\nGet started with Transformers right away with the [Pipeline](https://huggingface.co/docs/transformers/pipeline_tutorial) API. The `Pipeline` is a high-level inference class that supports text, audio, vision, and multimodal tasks. It handles preprocessing the input and returns the appropriate output.\n\nInstantiate a pipeline and specify model to use for text generation. The model is downloaded and cached so you can easily reuse it again. Finally, pass some text to prompt the model.\n\n```py\nfrom transformers import pipeline\n\npipeline = pipeline(task=\"text-generation\", model=\"Qwen/Qwen2.5-1.5B\")\npipeline(\"the secret to baking a really good cake is \")\n[{'generated_text': 'the secret to baking a really good cake is 1) to use the right ingredients and 2) to follow the recipe exactly. the recipe for the cake is as follows: 1 cup of sugar, 1 cup of flour, 1 cup of milk, 1 cup of butter, 1 cup of eggs, 1 cup of chocolate chips. if you want to make 2 cakes, how much sugar do you need? To make 2 cakes, you will need 2 cups of sugar.'}]\n```\n\nTo chat with a model, the usage pattern is the same. The only difference is you need to construct a chat history (the input to `Pipeline`) between you and the system.\n\n> [!TIP]\n> You can also chat with a model directly from the command line, as long as [`transformers serve` is running](https://huggingface.co/docs/transformers/main/en/serving).\n> ```shell\n> transformers chat Qwen/Qwen2.5-0.5B-Instruct\n> ```\n\n```py\nimport torch\nfrom transformers import pipeline\n\nchat = [\n {\"role\": \"system\", \"content\": \"You are a sassy, wise-cracking robot as imagined by Hollywood circa 1986.\"},\n {\"role\": \"user\", \"content\": \"Hey, can you tell me any fun things to do in New York?\"}\n]\n\npipeline = pipeline(task=\"text-generation\", model=\"meta-llama/Meta-Llama-3-8B-Instruct\", dtype=torch.bfloat16, device_map=\"auto\")\nresponse = pipeline(chat, max_new_tokens=512)\nprint(response[0][\"generated_text\"][-1][\"content\"])\n```\n\nExpand the examples below to see how `Pipeline` works for different modalities and tasks.\n\n<details>\n<summary>Automatic speech recognition</summary>\n\n```py\nfrom transformers import pipeline\n\npipeline = pipeline(task=\"automatic-speech-recognition\", model=\"openai/whisper-large-v3\")\npipeline(\"https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/mlk.flac\")\n{'text': ' I have a dream that one day this nation will rise up and live out the true meaning of its creed.'}\n```\n\n</details>\n\n<details>\n<summary>Image classification</summary>\n\n<h3 align=\"center\">\n <a><img src=\"https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png\"></a>\n</h3>\n\n```py\nfrom transformers import pipeline\n\npipeline = pipeline(task=\"image-classification\", model=\"facebook/dinov2-small-imagenet1k-1-layer\")\npipeline(\"https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png\")\n[{'label': 'macaw', 'score': 0.997848391532898},\n {'label': 'sulphur-crested cockatoo, Kakatoe galerita, Cacatua galerita',\n 'score': 0.0016551691805943847},\n {'label': 'lorikeet', 'score': 0.00018523589824326336},\n {'label': 'African grey, African gray, Psittacus erithacus',\n 'score': 7.85409429227002e-05},\n {'label': 'quail', 'score': 5.502637941390276e-05}]\n```\n\n</details>\n\n<details>\n<summary>Visual question answering</summary>\n\n<h3 align=\"center\">\n <a><img src=\"https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/idefics-few-shot.jpg\"></a>\n</h3>\n\n```py\nfrom transformers import pipeline\n\npipeline = pipeline(task=\"visual-question-answering\", model=\"Salesforce/blip-vqa-base\")\npipeline(\n image=\"https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/idefics-few-shot.jpg\",\n question=\"What is in the image?\",\n)\n[{'answer': 'statue of liberty'}]\n```\n\n</details>\n\n## Why should I use Transformers?\n\n1. Easy-to-use state-of-the-art models:\n - High performance on natural language understanding & generation, computer vision, audio, video, and multimodal tasks.\n - Low barrier to entry for researchers, engineers, and developers.\n - Few user-facing abstractions with just three classes to learn.\n - A unified API for using all our pretrained models.\n\n1. Lower compute costs, smaller carbon footprint:\n - Share trained models instead of training from scratch.\n - Reduce compute time and production costs.\n - Hundreds of model architectures with 1M+ pretrained checkpoints across all modalities.\n\n1. Choose the right framework for every part of a model's lifetime:\n - Train state-of-the-art models in 3 lines of code.\n - Move a single model between PyTorch/JAX/TF2.0 frameworks at will.\n - Pick the right framework for training, evaluation, and production.\n\n1. Easily customize a model or an example to your needs:\n - We provide examples for each architecture to reproduce the results published by its original authors.\n - Model internals are exposed as consistently as possible.\n - Model files can be used independently of the library for quick experiments.\n\n<a target=\"_blank\" href=\"https://huggingface.co/enterprise\">\n <img alt=\"Hugging Face Enterprise Hub\" src=\"https://github.com/user-attachments/assets/247fb16d-d251-4583-96c4-d3d76dda4925\">\n</a><br>\n\n## When shouldn't I use Transformers?\n\n- This library is not a modular toolbox of building blocks for neural nets. The code in the model files is not refactored with additional abstractions on purpose, so that researchers can quickly iterate on each of the models without diving into additional abstractions/files.\n- The training API is optimized to work with PyTorch models provided by Transformers. For generic machine learning loops, you should use another library like [Accelerate](https://huggingface.co/docs/accelerate).\n- The [example scripts](https://github.com/huggingface/transformers/tree/main/examples) are only *examples*. They may not necessarily work out-of-the-box on your specific use case and you'll need to adapt the code for it to work.\n\n## 100 projects using Transformers\n\nTransformers is more than a toolkit to use pretrained models, it's a community of projects built around it and the\nHugging Face Hub. We want Transformers to enable developers, researchers, students, professors, engineers, and anyone\nelse to build their dream projects.\n\nIn order to celebrate Transformers 100,000 stars, we wanted to put the spotlight on the\ncommunity with the [awesome-transformers](./awesome-transformers.md) page which lists 100\nincredible projects built with Transformers.\n\nIf you own or use a project that you believe should be part of the list, please open a PR to add it!\n\n## Example models\n\nYou can test most of our models directly on their [Hub model pages](https://huggingface.co/models).\n\nExpand each modality below to see a few example models for various use cases.\n\n<details>\n<summary>Audio</summary>\n\n- Audio classification with [CLAP](https://huggingface.co/laion/clap-htsat-fused)\n- Automatic speech recognition with [Parakeet](https://huggingface.co/nvidia/parakeet-ctc-1.1b#transcribing-using-transformers-%F0%9F%A4%97), [Whisper](https://huggingface.co/openai/whisper-large-v3-turbo), [GLM-ASR](https://huggingface.co/zai-org/GLM-ASR-Nano-2512) and [Moonshine-Streaming](https://huggingface.co/UsefulSensors/moonshine-streaming-medium)\n- Keyword spotting with [Wav2Vec2](https://huggingface.co/superb/wav2vec2-base-superb-ks)\n- Speech to speech generation with [Moshi](https://huggingface.co/kyutai/moshiko-pytorch-bf16)\n- Text to audio with [MusicGen](https://huggingface.co/facebook/musicgen-large)\n- Text to speech with [CSM](https://huggingface.co/sesame/csm-1b)\n\n</details>\n\n<details>\n<summary>Computer vision</summary>\n\n- Automatic mask generation with [SAM](https://huggingface.co/facebook/sam-vit-base)\n- Depth estimation with [DepthPro](https://huggingface.co/apple/DepthPro-hf)\n- Image classification with [DINO v2](https://huggingface.co/facebook/dinov2-base)\n- Keypoint detection with [SuperPoint](https://huggingface.co/magic-leap-community/superpoint)\n- Keypoint matching with [SuperGlue](https://huggingface.co/magic-leap-community/superglue_outdoor)\n- Object detection with [RT-DETRv2](https://huggingface.co/PekingU/rtdetr_v2_r50vd)\n- Pose Estimation with [VitPose](https://huggingface.co/usyd-community/vitpose-base-simple)\n- Universal segmentation with [OneFormer](https://huggingface.co/shi-labs/oneformer_ade20k_swin_large)\n- Video classification with [VideoMAE](https://huggingface.co/MCG-NJU/videomae-large)\n\n</details>\n\n<details>\n<summary>Multimodal</summary>\n\n- Audio or text to text with [Voxtral](https://huggingface.co/mistralai/Voxtral-Mini-3B-2507), [Audio Flamingo](https://huggingface.co/nvidia/audio-flamingo-3-hf)\n- Document question answering with [LayoutLMv3](https://huggingface.co/microsoft/layoutlmv3-base)\n- Image or text to text with [Qwen-VL](https://huggingface.co/Qwen/Qwen2.5-VL-3B-Instruct)\n- Image captioning [BLIP-2](https://huggingface.co/Salesforce/blip2-opt-2.7b)\n- OCR-based document understanding with [GOT-OCR2](https://huggingface.co/stepfun-ai/GOT-OCR-2.0-hf)\n- Table question answering with [TAPAS](https://huggingface.co/google/tapas-base)\n- Unified multimodal understanding and generation with [Emu3](https://huggingface.co/BAAI/Emu3-Gen)\n- Vision to text with [Llava-OneVision](https://huggingface.co/llava-hf/llava-onevision-qwen2-0.5b-ov-hf)\n- Visual question answering with [Llava](https://huggingface.co/llava-hf/llava-1.5-7b-hf)\n- Visual referring expression segmentation with [Kosmos-2](https://huggingface.co/microsoft/kosmos-2-patch14-224)\n\n</details>\n\n<details>\n<summary>NLP</summary>\n\n- Masked word completion with [ModernBERT](https://huggingface.co/answerdotai/ModernBERT-base)\n- Named entity recognition with [Gemma](https://huggingface.co/google/gemma-2-2b)\n- Question answering with [Mixtral](https://huggingface.co/mistralai/Mixtral-8x7B-v0.1)\n- Summarization with [BART](https://huggingface.co/facebook/bart-large-cnn)\n- Translation with [T5](https://huggingface.co/google-t5/t5-base)\n- Text generation with [Llama](https://huggingface.co/meta-llama/Llama-3.2-1B)\n- Text classification with [Qwen](https://huggingface.co/Qwen/Qwen2.5-0.5B)\n\n</details>\n\n## Citation\n\nWe now have a [paper](https://aclanthology.org/2020.emnlp-demos.6/) you can cite for the 🤗 Transformers library:\n```bibtex\n@inproceedings{wolf-etal-2020-transformers,\n title = \"Transformers: State-of-the-Art Natural Language Processing\",\n author = \"Thomas Wolf and Lysandre Debut and Victor Sanh and Julien Chaumond and Clement Delangue and Anthony Moi and Pierric Cistac and Tim Rault and Rémi Louf and Morgan Funtowicz and Joe Davison and Sam Shleifer and Patrick von Platen and Clara Ma and Yacine Jernite and Julien Plu and Canwen Xu and Teven Le Scao and Sylvain Gugger and Mariama Drame and Quentin Lhoest and Alexander M. Rush\",\n booktitle = \"Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing: System Demonstrations\",\n month = oct,\n year = \"2020\",\n address = \"Online\",\n publisher = \"Association for Computational Linguistics\",\n url = \"https://aclanthology.org/2020.emnlp-demos.6/\",\n pages = \"38--45\"\n}\n```",
"directory_tree": "├── .ai\n│ ├── skills\n│ │ └── add-or-fix-type-checking\n│ │ └── SKILL.md\n│ └── AGENTS.md\n├── .circleci\n│ ├── config.yml\n│ ├── config.yml.bak\n│ ├── create_circleci_config.py\n│ ├── parse_test_outputs.py\n│ └── TROUBLESHOOT.md\n├── .github\n│ ├── conda\n│ │ ├── build.sh\n│ │ └── meta.yaml\n│ ├── ISSUE_TEMPLATE\n│ │ ├── bug-report.yml\n│ │ ├── config.yml\n│ │ ├── feature-request.yml\n│ │ ├── i18n.md\n│ │ ├── migration.yml\n│ │ └── new-model-addition.yml\n│ ├── scripts\n│ │ ├── assign_reviewers.py\n│ │ └── codeowners_for_review_action\n│ ├── workflows\n│ │ ├── add-model-like.yml\n│ │ ├── anti-slop.yml\n│ │ ├── assign-reviewers.yml\n│ │ ├── benchmark.yml\n│ │ ├── benchmark_v2.yml\n│ │ ├── benchmark_v2_a10_caller.yml\n│ │ ├── benchmark_v2_mi300_caller.yml\n│ │ ├── build-ci-docker-images.yml\n│ │ ├── build-docker-images.yml\n│ │ ├── build-nightly-ci-docker-images.yml\n│ │ ├── build-past-ci-docker-images.yml\n│ │ ├── build_documentation.yml\n│ │ ├── build_pr_documentation.yml\n│ │ ├── check-workflow-permissions.yml\n│ │ ├── check_failed_tests.yml\n│ │ ├── check_tiny_models.yml\n│ │ ├── circleci-failure-summary-comment.yml.bak\n│ │ ├── codeql.yml\n│ │ ├── collated-reports.yml\n│ │ ├── dependents-smoke-test.yml\n│ │ ├── doctest_job.yml\n│ │ ├── doctests.yml\n│ │ ├── extras-smoke-test.yml\n│ │ ├── get-pr-info.yml\n│ │ ├── get-pr-number.yml\n│ │ ├── model_jobs.yml\n│ │ ├── model_jobs_intel_gaudi.yml\n│ │ ├── new_model_pr_merged_notification.yml\n│ │ ├── nightly-integration-failure-triage-caller.yml\n│ │ ├── pr-ci-caller.yml\n│ │ ├── pr-ci-post-dashboard-link.yml\n│ │ ├── pr-ci-security-gate.yml\n│ │ ├── pr-repo-consistency-bot.yml\n│ │ ├── pr_build_doc_with_comment.yml\n│ │ ├── pr_slow_ci_suggestion.yml\n│ │ ├── push-important-models.yml\n│ │ ├── release-conda.yml\n│ │ ├── release.yml\n│ │ ├── self-comment-ci.yml\n│ │ ├── self-nightly-caller.yml\n│ │ ├── self-nightly-past-ci-caller.yml\n│ │ ├── self-past-caller.yml\n│ │ ├── self-scheduled-amd-caller.yml\n│ │ ├── self-scheduled-amd-mi250-caller.yml\n│ │ ├── self-scheduled-amd-mi300-caller.yml\n│ │ ├── self-scheduled-amd-mi355-caller.yml\n│ │ ├── self-scheduled-caller.yml\n│ │ ├── self-scheduled-flash-attn-caller.yml\n│ │ ├── self-scheduled-intel-gaudi.yml\n│ │ ├── self-scheduled-intel-gaudi3-caller.yml\n│ │ ├── self-scheduled.yml\n│ │ ├── slack-report.yml\n│ │ ├── ssh-runner.yml\n│ │ ├── stale.yml\n│ │ ├── trl-ci-bot.yml\n│ │ ├── TROUBLESHOOT.md\n│ │ ├── trufflehog.yml\n│ │ ├── update_metdata.yml\n│ │ └── upload_pr_documentation.yml\n│ ├── copilot-instructions.md\n│ ├── dependabot.yml\n│ └── PULL_REQUEST_TEMPLATE.md\n├── benchmark\n│ ├── benches\n│ │ └── llama.py\n│ ├── config\n│ │ └── generation.yaml\n│ ├── utils\n│ │ └── init_db.sql\n│ ├── .gitignore\n│ ├── __init__.py\n│ ├── benchmark.py\n│ ├── benchmarks_entrypoint.py\n│ ├── default.yml\n│ ├── grafana_dashboard.json\n│ ├── grafana_datasource.yaml\n│ ├── optimum_benchmark_wrapper.py\n│ ├── README.md\n│ └── requirements.txt\n├── benchmark_v2\n│ ├── benchmark_scripts\n│ │ └── continuous_batching_overall.py\n│ ├── framework\n│ │ ├── benchmark_config.py\n│ │ ├── benchmark_runner.py\n│ │ ├── data_classes.py\n│ │ └── hardware_metrics.py\n│ ├── .gitignore\n│ ├── README.md\n│ ├── requirements.txt\n│ └── run_benchmarks.py\n├── docker\n│ ├── transformers-all-latest-gpu\n│ │ └── Dockerfile\n│ ├── transformers-doc-builder\n│ │ └── Dockerfile\n│ ├── transformers-gpu\n│ │ └── Dockerfile\n│ ├── transformers-intel-cpu\n│ │ └── Dockerfile\n│ ├── transformers-pytorch-amd-gpu\n│ │ └── Dockerfile\n│ ├── transformers-pytorch-deepspeed-amd-gpu\n│ │ └── Dockerfile\n│ ├── transformers-pytorch-deepspeed-latest-gpu\n│ │ └── Dockerfile\n│ ├── transformers-pytorch-deepspeed-nightly-gpu\n│ │ └── Dockerfile\n│ ├── transformers-pytorch-gpu\n│ │ └── Dockerfile\n│ ├── transformers-pytorch-tpu\n│ │ ├── bert-base-cased.jsonnet\n│ │ ├── dataset.yaml\n│ │ ├── docker-entrypoint.sh\n│ │ └── Dockerfile\n│ ├── transformers-pytorch-xpu\n│ │ └── Dockerfile\n│ ├── transformers-quantization-latest-gpu\n│ │ └── Dockerfile\n│ ├── consistency.dockerfile\n│ ├── custom-tokenizers.dockerfile\n│ ├── examples-torch.dockerfile\n│ ├── exotic-models.dockerfile\n│ ├── pipeline-torch.dockerfile\n│ ├── quality.dockerfile\n│ ├── README.md\n│ └── torch-light.dockerfile\n├── docs\n│ ├── source\n│ │ ├── ar\n│ │ │ ├── tasks\n│ │ │ │ ├── language_modeling.md\n│ │ │ │ ├── masked_language_modeling.md\n│ │ │ │ ├── multiple_choice.md\n│ │ │ │ ├── question_answering.md\n│ │ │ │ ├── sequence_classification.md\n│ │ │ │ ├── summarization.md\n│ │ │ │ ├── token_classification.md\n│ │ │ │ └── translation.md\n│ │ │ ├── _config.py\n│ │ │ ├── _toctree.yml\n│ │ │ ├── accelerate.md\n│ │ │ ├── attention.md\n│ │ │ ├── autoclass_tutorial.md\n│ │ │ ├── bertology.md\n│ │ │ ├── chat_templating.md\n│ │ │ ├── community.md\n│ │ │ ├── conversations.md\n│ │ │ ├── create_a_model.md\n│ │ │ ├── custom_models.md\n│ │ │ ├── fast_tokenizers.md\n│ │ │ ├── gguf.md\n│ │ │ ├── glossary.md\n│ │ │ ├── how_to_hack_models.md\n│ │ │ ├── index.md\n│ │ │ ├── installation.md\n│ │ │ ├── llm_tutorial.md\n│ │ │ ├── llm_tutorial_optimization.md\n│ │ │ ├── model_memory_anatomy.md\n│ │ │ ├── model_sharing.md\n│ │ │ ├── model_summary.md\n│ │ │ ├── modular_transformers.md\n│ │ │ ├── multilingual.md\n│ │ │ ├── notebooks.md\n│ │ │ ├── pad_truncation.md\n│ │ │ ├── peft.md\n│ │ │ ├── perplexity.md\n│ │ │ ├── philosophy.md\n│ │ │ ├── pipeline_tutorial.md\n│ │ │ ├── pipeline_webserver.md\n│ │ │ ├── preprocessing.md\n│ │ │ ├── quicktour.md\n│ │ │ ├── run_scripts.md\n│ │ │ ├── sagemaker.md\n│ │ │ ├── serialization.md\n│ │ │ ├── task_summary.md\n│ │ │ ├── tasks_explained.md\n│ │ │ ├── tiktoken.md\n│ │ │ ├── tokenizer_summary.md\n│ │ │ ├── trainer.md\n│ │ │ ├── training.md\n│ │ │ └── troubleshooting.md\n│ │ ├── de\n│ │ │ ├── _config.py\n│ │ │ ├── _toctree.yml\n│ │ │ ├── accelerate.md\n│ │ │ ├── add_new_model.md\n│ │ │ ├── add_new_pipeline.md\n│ │ │ ├── autoclass_tutorial.md\n│ │ │ ├── contributing.md\n│ │ │ ├── index.md\n│ │ │ ├── installation.md\n│ │ │ ├── llm_tutorial.md\n│ │ │ ├── model_sharing.md\n│ │ │ ├── peft.md\n│ │ │ ├── pipeline_tutorial.md\n│ │ │ ├── pr_checks.md\n│ │ │ ├── preprocessing.md\n│ │ │ ├── quicktour.md\n│ │ │ ├── run_scripts.md\n│ │ │ ├── testing.md\n│ │ │ └── training.md\n│ │ ├── en\n│ │ │ ├── community_integrations\n│ │ │ │ ├── axolotl.md\n│ │ │ │ ├── candle.md\n│ │ │ │ ├── executorch.md\n│ │ │ │ ├── llama_cpp.md\n│ │ │ │ ├── mlx.md\n│ │ │ │ ├── nanotron.md\n│ │ │ │ ├── nemo_automodel_finetuning.md\n│ │ │ │ ├── nemo_automodel_pretraining.md\n│ │ │ │ ├── sglang.md\n│ │ │ │ ├── tensorrt-llm.md\n│ │ │ │ ├── torchtitan.md\n│ │ │ │ ├── transformers_as_backend.md\n│ │ │ │ ├── trl.md\n│ │ │ │ ├── unsloth.md\n│ │ │ │ └── vllm.md\n│ │ │ ├── internal\n│ │ │ │ ├── audio_utils.md\n│ │ │ │ ├── file_utils.md\n│ │ │ │ ├── generation_utils.md\n│ │ │ │ ├── image_processing_utils.md\n│ │ │ │ ├── import_utils.md\n│ │ │ │ ├── model_debugging_utils.md\n│ │ │ │ ├── modeling_utils.md\n│ │ │ │ ├── pipelines_utils.md\n│ │ │ │ ├── rope_utils.md\n│ │ │ │ ├── time_series_utils.md\n│ │ │ │ ├── tokenization_utils.md\n│ │ │ │ └── trainer_utils.md\n│ │ │ ├── kernel_doc\n│ │ │ │ ├── loading_kernels.md\n│ │ │ │ ├── overview.md\n│ │ │ │ └── writing_kernels.md\n│ │ │ ├── main_classes\n│ │ │ │ ├── backbones.md\n│ │ │ │ ├── callback.md\n│ │ │ │ ├── configuration.md\n│ │ │ │ ├── continuous_batching.md\n│ │ │ │ ├── data_collator.md\n│ │ │ │ ├── deepspeed.md\n│ │ │ │ ├── executorch.md\n│ │ │ │ ├── exporters.md\n│ │ │ │ ├── feature_extractor.md\n│ │ │ │ ├── image_processor.md\n│ │ │ │ ├── kernels.md\n│ │ │ │ ├── logging.md\n│ │ │ │ ├── model.md\n│ │ │ │ ├── optimizer_schedules.md\n│ │ │ │ ├── output.md\n│ │ │ │ ├── peft.md\n│ │ │ │ ├── pipelines.md\n│ │ │ │ ├── processors.md\n│ │ │ │ ├── quantization.md\n│ │ │ │ ├── text_generation.md\n│ │ │ │ ├── tokenizer.md\n│ │ │ │ ├── trainer.md\n│ │ │ │ └── video_processor.md\n│ │ │ ├── model_doc\n│ │ │ │ ├── afmoe.md\n│ │ │ │ ├── aimv2.md\n│ │ │ │ ├── albert.md\n│ │ │ │ ├── align.md\n│ │ │ │ ├── altclip.md\n│ │ │ │ ├── apertus.md\n│ │ │ │ ├── arcee.md\n│ │ │ │ ├── aria.md\n│ │ │ │ ├── audio-spectrogram-transformer.md\n│ │ │ │ ├── audioflamingo3.md\n│ │ │ │ ├── auto.md\n│ │ │ │ ├── autoformer.md\n│ │ │ │ ├── aya_vision.md\n... (7173 more entries omitted)",
"main_features": [
"Why should I use Transformers?",
"When shouldn't I use Transformers?",
"projects using Transformers",
"Example models",
"Citation"
],
"metadata": {
"owner": "huggingface",
"default_branch": "main",
"topics": [
"audio",
"deep-learning",
"deepseek",
"gemma",
"glm",
"hacktoberfest",
"llm",
"machine-learning",
"model-hub",
"natural-language-processing",
"nlp",
"pretrained-models",
"python",
"pytorch",
"pytorch-transformers",
"qwen",
"speech-recognition",
"transformer",
"vlm"
]
}
}
\ No newline at end of file
{
"repo_name": "langchain",
"repo_url": "https://github.com/langchain-ai/langchain",
"stars": 141638,
"primary_language": "Python",
"updated_at": "2026-07-13T07:59:32Z",
"readme_text": "<div align=\"center\">\n <a href=\"https://docs.langchain.com/oss/python/langchain/overview\">\n <picture>\n <source media=\"(prefers-color-scheme: dark)\" srcset=\".github/images/logo-dark.svg\">\n <source media=\"(prefers-color-scheme: light)\" srcset=\".github/images/logo-light.svg\">\n <img alt=\"LangChain Logo\" src=\".github/images/logo-dark.svg\" width=\"50%\">\n </picture>\n </a>\n</div>\n\n<div align=\"center\">\n <h3>The agent engineering platform.</h3>\n</div>\n\n<div align=\"center\">\n <a href=\"https://opensource.org/licenses/MIT\" target=\"_blank\"><img src=\"https://img.shields.io/pypi/l/langchain\" alt=\"PyPI - License\"></a>\n <a href=\"https://pypistats.org/packages/langchain\" target=\"_blank\"><img src=\"https://img.shields.io/pepy/dt/langchain\" alt=\"PyPI - Downloads\"></a>\n <a href=\"https://pypi.org/project/langchain/#history\" target=\"_blank\"><img src=\"https://img.shields.io/pypi/v/langchain?label=%20\" alt=\"Version\"></a>\n <a href=\"https://x.com/langchain_oss\" target=\"_blank\"><img src=\"https://img.shields.io/twitter/url/https/twitter.com/langchain_oss.svg?style=social&label=Follow%20%40LangChain\" alt=\"Twitter / X\"></a>\n</div>\n\n<br>\n\nLangChain is a framework for building agents and LLM-powered applications. It helps you chain together interoperable components and third-party integrations to simplify AI application development — all while future-proofing decisions as the underlying technology evolves.\n\n> [!TIP]\n> Just getting started? Check out **[Deep Agents](http://docs.langchain.com/oss/python/deepagents/)** — a higher-level package built on LangChain for agents that have built-in capabilites for common usage patterns such as planning, subagents, file system usage, and more.\n\n## Quickstart\n\n```bash\nuv add langchain\n```\n\n```python\nfrom langchain.chat_models import init_chat_model\n\nmodel = init_chat_model(\"openai:gpt-5.5\")\nresult = model.invoke(\"Hello, world!\")\n```\n\nIf you're looking for more advanced customization or agent orchestration, check out [LangGraph](https://github.com/langchain-ai/langgraph), our framework for building controllable agent workflows.\n\nFor an equivalent JS/TS library, check out [LangChain.js](https://github.com/langchain-ai/langchainjs).\n\n> [!TIP]\n> For developing, debugging, and deploying AI agents and LLM applications, see [LangSmith](https://docs.langchain.com/langsmith/home).\n\n## LangChain ecosystem\n\nWhile the LangChain framework can be used standalone, it also integrates seamlessly with any LangChain product, giving developers a full suite of tools when building LLM applications.\n\n- **[Deep Agents](http://docs.langchain.com/oss/python/deepagents/)** — Build agents that can plan, use subagents, and leverage file systems for complex tasks\n- **[LangGraph](https://docs.langchain.com/oss/python/langgraph/overview)** — Build agents that can reliably handle complex tasks with our low-level agent orchestration framework\n- **[Integrations](https://docs.langchain.com/oss/python/integrations/providers/overview)** — Chat & embedding models, tools & toolkits, and more\n- **[LangSmith](https://www.langchain.com/langsmith)** — Agent evals, observability, and debugging for LLM apps\n- **[LangSmith Deployment](https://docs.langchain.com/langsmith/deployments)** — Deploy and scale agents with a purpose-built platform for long-running, stateful workflows\n\n## Why use LangChain?\n\nLangChain helps developers build applications powered by LLMs through a standard interface for models, embeddings, vector stores, and more.\n\n- **Real-time data augmentation** — Easily connect LLMs to diverse data sources and external/internal systems, drawing from LangChain's vast library of integrations with model providers, tools, vector stores, retrievers, and more\n- **Model interoperability** — Swap models in and out as your engineering team experiments to find the best choice for your application's needs. As the industry frontier evolves, adapt quickly — LangChain's abstractions keep you moving without losing momentum\n- **Rapid prototyping** — Quickly build and iterate on LLM applications with LangChain's modular, component-based architecture. Test different approaches and workflows without rebuilding from scratch, accelerating your development cycle\n- **Production-ready features** — Deploy reliable applications with built-in support for monitoring, evaluation, and debugging through integrations like LangSmith. Scale with confidence using battle-tested patterns and best practices\n- **Vibrant community and ecosystem** — Leverage a rich ecosystem of integrations, templates, and community-contributed components. Benefit from continuous improvements and stay up-to-date with the latest AI developments through an active open-source community\n- **Flexible abstraction layers** — Work at the level of abstraction that suits your needs — from high-level chains for quick starts to low-level components for fine-grained control. LangChain grows with your application's complexity\n\n---\n\n## Resources\n\n- [Documentation](https://docs.langchain.com/oss/python/langchain/overview) — conceptual overviews and guides\n- [LangChain ecosystem overview](https://docs.langchain.com/oss/python/concepts/products) — how LangChain, LangGraph, and Deep Agents fit together\n- [API reference](https://reference.langchain.com/python) — complete reference for all public classes, functions, and types\n- [Discussions](https://forum.langchain.com/c/oss-product-help-lc-and-lg/langchain/14) — community forum for technical questions, ideas, and feedback\n- [LangChain Academy](https://academy.langchain.com/) — comprehensive, free courses on LangChain libraries and products, made by the LangChain team\n- [Contributing Guide](https://docs.langchain.com/oss/python/contributing/overview) — how to contribute and find good first issues\n- [Code of Conduct](https://github.com/langchain-ai/langchain/?tab=coc-ov-file) — community guidelines and standards",
"directory_tree": "├── .devcontainer\n│ ├── devcontainer.json\n│ ├── docker-compose.yaml\n│ └── README.md\n├── .github\n│ ├── actions\n│ │ └── uv_setup\n│ │ └── action.yml\n│ ├── images\n│ │ ├── logo-dark.svg\n│ │ └── logo-light.svg\n│ ├── ISSUE_TEMPLATE\n│ │ ├── bug-report.yml\n│ │ ├── config.yml\n│ │ ├── feature-request.yml\n│ │ ├── privileged.yml\n│ │ └── task.yml\n│ ├── scripts\n│ │ ├── check_diff.py\n│ │ ├── check_extras_sync.py\n│ │ ├── check_prerelease_dependencies.py\n│ │ ├── get_min_versions.py\n│ │ ├── pr-labeler-config.json\n│ │ ├── pr-labeler.js\n│ │ └── test_release_options.py\n│ ├── tools\n│ │ └── git-restore-mtime\n│ ├── workflows\n│ │ ├── _compile_integration_test.yml\n│ │ ├── _lint.yml\n│ │ ├── _refresh_model_profiles.yml\n│ │ ├── _release.yml\n│ │ ├── _test.yml\n│ │ ├── _test_pydantic.yml\n│ │ ├── _test_vcr.yml\n│ │ ├── auto-label-by-package.yml\n│ │ ├── block_fork_main_prs.yml\n│ │ ├── bump_uv_pin.yml\n│ │ ├── check_agents_sync.yml\n│ │ ├── check_diffs.yml\n│ │ ├── check_extras_sync.yml\n│ │ ├── check_release_deps.yml\n│ │ ├── check_versions.yml\n│ │ ├── close_unchecked_issues.yml\n│ │ ├── codspeed.yml\n│ │ ├── integration_tests.yml\n│ │ ├── pr_labeler.yml\n│ │ ├── pr_labeler_backfill.yml\n│ │ ├── pr_lint.yml\n│ │ ├── pr_lint_trailer.yml\n│ │ ├── refresh_model_profiles.yml\n│ │ ├── remove_waiting_on_author.yml\n│ │ ├── reopen_on_assignment.yml\n│ │ ├── require_issue_link.yml\n│ │ └── tag-external-issues.yml\n│ ├── CODEOWNERS\n│ ├── dependabot.yml\n│ └── PULL_REQUEST_TEMPLATE.md\n├── .vscode\n│ ├── extensions.json\n│ └── settings.json\n├── libs\n│ ├── core\n│ │ ├── langchain_core\n│ │ │ ├── _api\n│ │ │ │ ├── __init__.py\n│ │ │ │ ├── beta_decorator.py\n│ │ │ │ ├── deprecation.py\n│ │ │ │ ├── internal.py\n│ │ │ │ └── path.py\n│ │ │ ├── _security\n│ │ │ │ ├── __init__.py\n│ │ │ │ ├── _exceptions.py\n│ │ │ │ ├── _policy.py\n│ │ │ │ ├── _ssrf_protection.py\n│ │ │ │ └── _transport.py\n│ │ │ ├── callbacks\n│ │ │ │ ├── __init__.py\n│ │ │ │ ├── base.py\n│ │ │ │ ├── file.py\n│ │ │ │ ├── manager.py\n│ │ │ │ ├── stdout.py\n│ │ │ │ ├── streaming_stdout.py\n│ │ │ │ └── usage.py\n│ │ │ ├── document_loaders\n│ │ │ │ ├── __init__.py\n│ │ │ │ ├── base.py\n│ │ │ │ ├── blob_loaders.py\n│ │ │ │ └── langsmith.py\n│ │ │ ├── documents\n│ │ │ │ ├── __init__.py\n│ │ │ │ ├── base.py\n│ │ │ │ ├── compressor.py\n│ │ │ │ └── transformers.py\n│ │ │ ├── embeddings\n│ │ │ │ ├── __init__.py\n│ │ │ │ ├── embeddings.py\n│ │ │ │ └── fake.py\n│ │ │ ├── example_selectors\n│ │ │ │ ├── __init__.py\n│ │ │ │ ├── base.py\n│ │ │ │ ├── length_based.py\n│ │ │ │ └── semantic_similarity.py\n│ │ │ ├── indexing\n│ │ │ │ ├── __init__.py\n│ │ │ │ ├── api.py\n│ │ │ │ ├── base.py\n│ │ │ │ └── in_memory.py\n│ │ │ ├── language_models\n│ │ │ │ ├── __init__.py\n│ │ │ │ ├── _compat_bridge.py\n│ │ │ │ ├── _utils.py\n│ │ │ │ ├── base.py\n│ │ │ │ ├── chat_model_stream.py\n│ │ │ │ ├── chat_models.py\n│ │ │ │ ├── fake.py\n│ │ │ │ ├── fake_chat_models.py\n│ │ │ │ ├── llms.py\n│ │ │ │ └── model_profile.py\n│ │ │ ├── load\n│ │ │ │ ├── __init__.py\n│ │ │ │ ├── _validation.py\n│ │ │ │ ├── dump.py\n│ │ │ │ ├── load.py\n│ │ │ │ ├── mapping.py\n│ │ │ │ └── serializable.py\n│ │ │ ├── messages\n│ │ │ │ ├── block_translators\n│ │ │ │ │ ├── __init__.py\n│ │ │ │ │ ├── anthropic.py\n│ │ │ │ │ ├── bedrock.py\n│ │ │ │ │ ├── bedrock_converse.py\n│ │ │ │ │ ├── google_genai.py\n│ │ │ │ │ ├── google_vertexai.py\n│ │ │ │ │ ├── groq.py\n│ │ │ │ │ ├── langchain_v0.py\n│ │ │ │ │ └── openai.py\n│ │ │ │ ├── __init__.py\n│ │ │ │ ├── ai.py\n│ │ │ │ ├── base.py\n│ │ │ │ ├── chat.py\n│ │ │ │ ├── content.py\n│ │ │ │ ├── function.py\n│ │ │ │ ├── human.py\n│ │ │ │ ├── modifier.py\n│ │ │ │ ├── system.py\n│ │ │ │ ├── tool.py\n│ │ │ │ └── utils.py\n│ │ │ ├── output_parsers\n│ │ │ │ ├── __init__.py\n│ │ │ │ ├── base.py\n│ │ │ │ ├── format_instructions.py\n│ │ │ │ ├── json.py\n│ │ │ │ ├── list.py\n│ │ │ │ ├── openai_functions.py\n│ │ │ │ ├── openai_tools.py\n│ │ │ │ ├── pydantic.py\n│ │ │ │ ├── string.py\n│ │ │ │ ├── transform.py\n│ │ │ │ └── xml.py\n│ │ │ ├── outputs\n│ │ │ │ ├── __init__.py\n│ │ │ │ ├── chat_generation.py\n│ │ │ │ ├── chat_result.py\n│ │ │ │ ├── generation.py\n│ │ │ │ ├── llm_result.py\n│ │ │ │ └── run_info.py\n│ │ │ ├── prompts\n│ │ │ │ ├── __init__.py\n│ │ │ │ ├── base.py\n│ │ │ │ ├── chat.py\n│ │ │ │ ├── dict.py\n│ │ │ │ ├── few_shot.py\n│ │ │ │ ├── few_shot_with_templates.py\n│ │ │ │ ├── image.py\n│ │ │ │ ├── loading.py\n│ │ │ │ ├── message.py\n│ │ │ │ ├── prompt.py\n│ │ │ │ ├── string.py\n│ │ │ │ └── structured.py\n│ │ │ ├── runnables\n│ │ │ │ ├── __init__.py\n│ │ │ │ ├── base.py\n│ │ │ │ ├── branch.py\n│ │ │ │ ├── config.py\n│ │ │ │ ├── configurable.py\n│ │ │ │ ├── fallbacks.py\n│ │ │ │ ├── graph.py\n│ │ │ │ ├── graph_ascii.py\n│ │ │ │ ├── graph_mermaid.py\n│ │ │ │ ├── graph_png.py\n│ │ │ │ ├── history.py\n│ │ │ │ ├── passthrough.py\n│ │ │ │ ├── retry.py\n│ │ │ │ ├── router.py\n│ │ │ │ ├── schema.py\n│ │ │ │ └── utils.py\n│ │ │ ├── tools\n│ │ │ │ ├── __init__.py\n│ │ │ │ ├── base.py\n│ │ │ │ ├── convert.py\n│ │ │ │ ├── render.py\n│ │ │ │ ├── retriever.py\n│ │ │ │ ├── simple.py\n│ │ │ │ └── structured.py\n│ │ │ ├── tracers\n│ │ │ │ ├── __init__.py\n│ │ │ │ ├── _compat.py\n│ │ │ │ ├── _streaming.py\n│ │ │ │ ├── base.py\n│ │ │ │ ├── context.py\n│ │ │ │ ├── core.py\n│ │ │ │ ├── evaluation.py\n│ │ │ │ ├── event_stream.py\n│ │ │ │ ├── langchain.py\n│ │ │ │ ├── log_stream.py\n│ │ │ │ ├── memory_stream.py\n│ │ │ │ ├── root_listeners.py\n│ │ │ │ ├── run_collector.py\n│ │ │ │ ├── schemas.py\n│ │ │ │ └── stdout.py\n│ │ │ ├── utils\n│ │ │ │ ├── __init__.py\n│ │ │ │ ├── _merge.py\n│ │ │ │ ├── aiter.py\n│ │ │ │ ├── env.py\n│ │ │ │ ├── formatting.py\n│ │ │ │ ├── function_calling.py\n│ │ │ │ ├── html.py\n│ │ │ │ ├── image.py\n│ │ │ │ ├── input.py\n│ │ │ │ ├── interactive_env.py\n│ │ │ │ ├── iter.py\n│ │ │ │ ├── json.py\n│ │ │ │ ├── json_schema.py\n│ │ │ │ ├── mustache.py\n│ │ │ │ ├── pydantic.py\n│ │ │ │ ├── strings.py\n│ │ │ │ ├── usage.py\n│ │ │ │ ├── utils.py\n│ │ │ │ └── uuid.py\n│ │ │ ├── vectorstores\n│ │ │ │ ├── __init__.py\n│ │ │ │ ├── base.py\n│ │ │ │ ├── in_memory.py\n│ │ │ │ └── utils.py\n│ │ │ ├── __init__.py\n│ │ │ ├── _import_utils.py\n│ │ │ ├── agents.py\n│ │ │ ├── caches.py\n│ │ │ ├── chat_history.py\n│ │ │ ├── chat_loaders.py\n│ │ │ ├── chat_sessions.py\n│ │ │ ├── cross_encoders.py\n│ │ │ ├── env.py\n│ │ │ ├── exceptions.py\n│ │ │ ├── globals.py\n│ │ │ ├── prompt_values.py\n│ │ │ ├── py.typed\n│ │ │ ├── rate_limiters.py\n│ │ │ ├── retrievers.py\n│ │ │ ├── stores.py\n│ │ │ ├── structured_query.py\n│ │ │ ├── sys_info.py\n│ │ │ └── version.py\n│ │ ├── scripts\n│ │ │ ├── check_imports.py\n│ │ │ ├── check_version.py\n│ │ │ └── lint_imports.sh\n│ │ ├── tests\n│ │ │ ├── benchmarks\n│ │ │ │ ├── __init__.py\n│ │ │ │ ├── test_async_callbacks.py\n│ │ │ │ ├── test_imports.py\n│ │ │ │ └── test_tool_schema_conversion.py\n│ │ │ ├── integration_tests\n│ │ │ │ ├── __init__.py\n│ │ │ │ └── test_compile.py\n│ │ │ ├── unit_tests\n│ │ │ │ ├── _api\n│ │ │ │ │ ├── __init__.py\n│ │ │ │ │ ├── test_beta_decorator.py\n│ │ │ │ │ ├── test_deprecation.py\n│ │ │ │ │ ├── test_imports.py\n│ │ │ │ │ └── test_path.py\n│ │ │ │ ├── caches\n│ │ │ │ │ ├── __init__.py\n│ │ │ │ │ └── test_in_memory_cache.py\n│ │ │ │ ├── callbacks\n│ │ │ │ │ ├── __init__.py\n│ │ │ │ │ ├── test_async_callback_manager.py\n│ │ │ │ │ ├── test_dispatch_custom_event.py\n│ │ │ │ │ ├── test_handle_event.py\n│ │ │ │ │ ├── test_imports.py\n│ │ │ │ │ ├── test_sync_callback_manager.py\n│ │ │ │ │ └── test_usage_callback.py\n│ │ │ │ ├── chat_history\n│ │ │ │ │ ├── __init__.py\n│ │ │ │ │ └── test_chat_history.py\n│ │ │ │ ├── data\n... (3274 more entries omitted)",
"main_features": [
"LangChain ecosystem",
"Why use LangChain?"
],
"metadata": {
"owner": "langchain-ai",
"default_branch": "master",
"topics": [
"agents",
"ai",
"ai-agents",
"anthropic",
"chatgpt",
"deepagents",
"enterprise",
"framework",
"gemini",
"generative-ai",
"langchain",
"langgraph",
"llm",
"multiagent",
"open-source",
"openai",
"pydantic",
"python",
"rag",
"typescript"
]
}
}
\ No newline at end of file
{
"repo_name": "vscode",
"repo_url": "https://github.com/microsoft/vscode",
"stars": 187487,
"primary_language": "TypeScript",
"updated_at": "2026-07-13T08:02:45Z",
"readme_text": "# Visual Studio Code - Open Source (\"Code - OSS\")\n[![Feature Requests](https://img.shields.io/github/issues/microsoft/vscode/feature-request.svg)](https://github.com/microsoft/vscode/issues?q=is%3Aopen+is%3Aissue+label%3Afeature-request+sort%3Areactions-%2B1-desc)\n[![Bugs](https://img.shields.io/github/issues/microsoft/vscode/bug.svg)](https://github.com/microsoft/vscode/issues?utf8=✓&q=is%3Aissue+is%3Aopen+label%3Abug)\n[![Gitter](https://img.shields.io/badge/chat-on%20gitter-yellow.svg)](https://gitter.im/Microsoft/vscode)\n\n## The Repository\n\nThis repository (\"`Code - OSS`\") is where we (Microsoft) develop the [Visual Studio Code](https://code.visualstudio.com) product together with the community. Not only do we work on code and issues here, but we also publish our [roadmap](https://github.com/microsoft/vscode/wiki/Roadmap), [monthly iteration plans](https://github.com/microsoft/vscode/wiki/Iteration-Plans), and our [endgame plans](https://github.com/microsoft/vscode/wiki/Running-the-Endgame). This source code is available to everyone under the standard [MIT license](https://github.com/microsoft/vscode/blob/main/LICENSE.txt).\n\n## Visual Studio Code\n\n<p align=\"center\">\n <img alt=\"VS Code in action\" src=\"https://github.com/user-attachments/assets/56af271c-949d-454c-a3ea-16188c063414\">\n</p>\n\n[Visual Studio Code](https://code.visualstudio.com) is a distribution of the `Code - OSS` repository with Microsoft-specific customizations released under a traditional [Microsoft product license](https://code.visualstudio.com/License/).\n\n[Visual Studio Code](https://code.visualstudio.com) combines the simplicity of a code editor with what developers need for their core edit-build-debug cycle. It provides comprehensive code editing, navigation, and understanding support along with lightweight debugging, a rich extensibility model, and lightweight integration with existing tools.\n\nVisual Studio Code is updated monthly with new features and bug fixes. You can download it for Windows, macOS, and Linux on [Visual Studio Code's website](https://code.visualstudio.com/Download). To get the latest releases every day, install the [Insiders build](https://code.visualstudio.com/insiders).\n\n## Contributing\n\nThere are many ways in which you can participate in this project, for example:\n\n* [Submit bugs and feature requests](https://github.com/microsoft/vscode/issues), and help us verify as they are checked in\n* Review [source code changes](https://github.com/microsoft/vscode/pulls)\n* Review the [documentation](https://github.com/microsoft/vscode-docs) and make pull requests for anything from typos to new content.\n\nIf you are interested in fixing issues and contributing directly to the code base,\nplease see the document [How to Contribute](https://github.com/microsoft/vscode/wiki/How-to-Contribute), which covers the following:\n\n* [How to build and run from source](https://github.com/microsoft/vscode/wiki/How-to-Contribute)\n* [The development workflow, including debugging and running tests](https://github.com/microsoft/vscode/wiki/How-to-Contribute#debugging)\n* [Coding guidelines](https://github.com/microsoft/vscode/wiki/Coding-Guidelines)\n* [Submitting pull requests](https://github.com/microsoft/vscode/wiki/How-to-Contribute#pull-requests)\n* [Finding an issue to work on](https://github.com/microsoft/vscode/wiki/How-to-Contribute#where-to-contribute)\n* [Contributing to translations](https://aka.ms/vscodeloc)\n\n## Feedback\n\n* Ask a question on [Stack Overflow](https://stackoverflow.com/questions/tagged/vscode)\n* [Request a new feature](CONTRIBUTING.md)\n* Upvote [popular feature requests](https://github.com/microsoft/vscode/issues?q=is%3Aopen+is%3Aissue+label%3Afeature-request+sort%3Areactions-%2B1-desc)\n* [File an issue](https://github.com/microsoft/vscode/issues)\n* Connect with the extension author community on [GitHub Discussions](https://github.com/microsoft/vscode-discussions/discussions) or [Slack](https://aka.ms/vscode-dev-community)\n* Follow [@code](https://x.com/code) and let us know what you think!\n\nSee our [wiki](https://github.com/microsoft/vscode/wiki/Feedback-Channels) for a description of each of these channels and information on some other available community-driven channels.\n\n## Related Projects\n\nMany of the core components and extensions to VS Code live in their own repositories on GitHub. For example, the [node debug adapter](https://github.com/microsoft/vscode-node-debug) and the [mono debug adapter](https://github.com/microsoft/vscode-mono-debug) repositories are separate from each other. For a complete list, please visit the [Related Projects](https://github.com/microsoft/vscode/wiki/Related-Projects) page on our [wiki](https://github.com/microsoft/vscode/wiki).\n\n## Bundled Extensions\n\nVS Code includes a set of built-in extensions located in the [extensions](extensions) folder, including grammars and snippets for many languages. Extensions that provide rich language support (inline suggestions, Go to Definition) for a language have the suffix `language-features`. For example, the `json` extension provides coloring for `JSON` and the `json-language-features` extension provides rich language support for `JSON`.\n\n## Development Container\n\nThis repository includes a Visual Studio Code Dev Containers / GitHub Codespaces development container.\n\n* For [Dev Containers](https://aka.ms/vscode-remote/download/containers), use the **Dev Containers: Clone Repository in Container Volume...** command which creates a Docker volume for better disk I/O on macOS and Windows.\n * If you already have VS Code and Docker installed, you can also click [here](https://vscode.dev/redirect?url=vscode://ms-vscode-remote.remote-containers/cloneInVolume?url=https://github.com/microsoft/vscode) to get started. This will cause VS Code to automatically install the Dev Containers extension if needed, clone the source code into a container volume, and spin up a dev container for use.\n\n* For Codespaces, install the [GitHub Codespaces](https://marketplace.visualstudio.com/items?itemName=GitHub.codespaces) extension in VS Code, and use the **Codespaces: Create New Codespace** command.\n\nDocker / the Codespace should have at least **4 cores and 6 GB of RAM (8 GB recommended)** to run a full build. See the [development container README](.devcontainer/README.md) for more information.\n\n## Code of Conduct\n\nThis project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.\n\n## License\n\nCopyright (c) Microsoft Corporation. All rights reserved.\n\nLicensed under the [MIT](LICENSE.txt) license.",
"directory_tree": "├── .agents\n│ └── skills\n│ └── launch\n│ ├── scripts\n│ │ ├── launch.sh\n│ │ └── monaco-paste.sh\n│ └── SKILL.md\n├── .config\n│ ├── 1espt\n│ │ └── PipelineAutobaseliningConfig.yml\n│ ├── guardian\n│ │ └── .gdnsuppress\n│ └── configuration.winget\n├── .devcontainer\n│ ├── devcontainer-lock.json\n│ ├── devcontainer.json\n│ ├── Dockerfile\n│ ├── install-vscode.sh\n│ ├── post-create.sh\n│ └── README.md\n├── .eslint-plugin-local\n│ ├── tests\n│ │ ├── code-no-observable-get-in-reactive-context-test.ts\n│ │ └── code-no-reader-after-await-test.ts\n│ ├── code-amd-node-module.ts\n│ ├── code-declare-service-brand.ts\n│ ├── code-ensure-no-disposables-leak-in-test.ts\n│ ├── code-import-patterns.ts\n│ ├── code-layering.ts\n│ ├── code-limited-top-functions.ts\n│ ├── code-must-use-result.ts\n│ ├── code-must-use-super-dispose.ts\n│ ├── code-no-accessor-after-await.ts\n│ ├── code-no-any-casts.ts\n│ ├── code-no-dangerous-type-assertions.ts\n│ ├── code-no-declare-const-enum.ts\n│ ├── code-no-deep-import-of-internal.ts\n│ ├── code-no-direct-gulp-import.ts\n│ ├── code-no-global-document-listener.ts\n│ ├── code-no-http-import.ts\n│ ├── code-no-icons-in-localized-strings.ts\n│ ├── code-no-in-operator.ts\n│ ├── code-no-localization-template-literals.ts\n│ ├── code-no-localized-model-description.ts\n│ ├── code-no-new-javascript-files.ts\n│ ├── code-no-nls-in-standalone-editor.ts\n│ ├── code-no-observable-get-in-reactive-context.ts\n│ ├── code-no-potentially-unsafe-disposables.ts\n│ ├── code-no-reader-after-await.ts\n│ ├── code-no-runtime-import.ts\n│ ├── code-no-standalone-editor.ts\n│ ├── code-no-static-node-module-import.ts\n│ ├── code-no-static-self-ref.ts\n│ ├── code-no-telemetry-common-property.ts\n│ ├── code-no-test-async-suite.ts\n│ ├── code-no-test-only.ts\n│ ├── code-no-unexternalized-strings.ts\n│ ├── code-no-untyped-meta-access.ts\n│ ├── code-no-unused-expressions.ts\n│ ├── code-parameter-properties-must-have-explicit-accessibility.ts\n│ ├── code-policy-localization-key-match.ts\n│ ├── code-translation-remind.ts\n│ ├── index.ts\n│ ├── package.json\n│ ├── README.md\n│ ├── tsconfig.json\n│ ├── utils.ts\n│ ├── vscode-dts-cancellation.ts\n│ ├── vscode-dts-create-func.ts\n│ ├── vscode-dts-event-naming.ts\n│ ├── vscode-dts-interface-naming.ts\n│ ├── vscode-dts-literal-or-types.ts\n│ ├── vscode-dts-provider-naming.ts\n│ ├── vscode-dts-string-type-literals.ts\n│ ├── vscode-dts-use-export.ts\n│ ├── vscode-dts-use-thenable.ts\n│ └── vscode-dts-vscode-in-comments.ts\n├── .github\n│ ├── actions\n│ │ ├── restore-node-modules\n│ │ │ └── action.yml\n│ │ └── save-node-modules\n│ │ └── action.yml\n│ ├── agents\n│ │ ├── data.md\n│ │ ├── demonstrate.md\n│ │ └── sessions.md\n│ ├── commands\n│ │ └── codespaces_issue.yml\n│ ├── endgame\n│ │ └── insiders.yml\n│ ├── instructions\n│ │ ├── resources\n│ │ │ ├── interactive\n│ │ │ │ ├── interactive.editor.drawio.svg\n│ │ │ │ ├── interactive.eh.drawio.svg\n│ │ │ │ └── interactive.model.resolution.drawio.svg\n│ │ │ └── notebook\n│ │ │ ├── cell-resize-above-viewport.drawio.svg\n│ │ │ ├── hybrid-find.drawio.svg\n│ │ │ └── viewport-rendering.drawio.svg\n│ │ ├── accessibility.instructions.md\n│ │ ├── agentHostTesting.instructions.md\n│ │ ├── ai-customization.instructions.md\n│ │ ├── best-practices.instructions.md\n│ │ ├── buildNext.instructions.md\n│ │ ├── chat.instructions.md\n│ │ ├── coding-guidelines.instructions.md\n│ │ ├── committing.instructions.md\n│ │ ├── design-philosophy.instructions.md\n│ │ ├── design-tokens.instructions.md\n│ │ ├── disposable.instructions.md\n│ │ ├── interactive.instructions.md\n│ │ ├── kusto.instructions.md\n│ │ ├── learnings.instructions.md\n│ │ ├── notebook.instructions.md\n│ │ ├── observables.instructions.md\n│ │ ├── oss-third-party-notices.instructions.md\n│ │ ├── oss.instructions.md\n│ │ ├── sessions.instructions.md\n│ │ ├── source-code-organization.instructions.md\n│ │ ├── telemetry.instructions.md\n│ │ ├── tree-widgets.instructions.md\n│ │ └── writing-tests.instructions.md\n│ ├── ISSUE_TEMPLATE\n│ │ ├── bug_report.md\n│ │ ├── config.yml\n│ │ ├── copilot_bug_report.md\n│ │ └── feature_request.md\n│ ├── prompts\n│ │ ├── build-champ.prompt.md\n│ │ ├── codenotify.prompt.md\n│ │ ├── component.prompt.md\n│ │ ├── doc-comments.prompt.md\n│ │ ├── find-duplicates.prompt.md\n│ │ ├── find-issue.prompt.md\n│ │ ├── fix-error.prompt.md\n│ │ ├── fixIssueNo.prompt.md\n│ │ ├── implement.prompt.md\n│ │ ├── issue-grouping.prompt.md\n│ │ ├── micro-perf.prompt.md\n│ │ ├── migrate.prompt.md\n│ │ ├── no-any.prompt.md\n│ │ ├── plan-deep.prompt.md\n│ │ ├── plan-fast.prompt.md\n│ │ ├── setup-environment.prompt.md\n│ │ └── update-instructions.prompt.md\n│ ├── skills\n│ │ ├── accessibility\n│ │ │ └── SKILL.md\n│ │ ├── add-policy\n│ │ │ ├── github-managed-settings.md\n│ │ │ ├── local-testing.md\n│ │ │ └── SKILL.md\n│ │ ├── agent-host-e2e-tests\n│ │ │ └── SKILL.md\n│ │ ├── agent-host-logs\n│ │ │ ├── scripts\n│ │ │ │ └── extract.py\n│ │ │ └── SKILL.md\n│ │ ├── author-contributions\n│ │ │ └── SKILL.md\n│ │ ├── auto-perf-optimize\n│ │ │ ├── scratchpad\n│ │ │ │ ├── .gitignore\n│ │ │ │ └── README.md\n│ │ │ ├── scripts\n│ │ │ │ ├── chat-memory-smoke.mts\n│ │ │ │ ├── chat-session-switch-smoke.mts\n│ │ │ │ └── userDataProfile.mts\n│ │ │ └── SKILL.md\n│ │ ├── azure-pipelines\n│ │ │ ├── azure-pipeline.ts\n│ │ │ └── SKILL.md\n│ │ ├── chat-customizations-editor\n│ │ │ └── SKILL.md\n│ │ ├── chat-perf\n│ │ │ └── SKILL.md\n│ │ ├── code-oss-logs\n│ │ │ └── SKILL.md\n│ │ ├── component-fixtures\n│ │ │ └── SKILL.md\n│ │ ├── cpu-profile-analysis\n│ │ │ └── SKILL.md\n│ │ ├── design-philosophy\n│ │ │ └── SKILL.md\n│ │ ├── fix-ci-failures\n│ │ │ └── SKILL.md\n│ │ ├── fix-errors\n│ │ │ └── SKILL.md\n│ │ ├── heap-snapshot-analysis\n│ │ │ ├── helpers\n│ │ │ │ ├── compareSnapshots.ts\n│ │ │ │ ├── findRetainers.ts\n│ │ │ │ ├── parseSnapshot.ts\n│ │ │ │ └── streamSnapshot.mjs\n│ │ │ ├── scratchpad\n│ │ │ │ ├── .gitignore\n│ │ │ │ └── README.md\n│ │ │ └── SKILL.md\n│ │ ├── hygiene\n│ │ │ └── SKILL.md\n│ │ ├── integrated-browser\n│ │ │ └── SKILL.md\n│ │ ├── integration-tests\n│ │ │ └── SKILL.md\n│ │ ├── memory-leak-audit\n│ │ │ └── SKILL.md\n│ │ ├── otel\n│ │ │ └── SKILL.md\n│ │ ├── sessions\n│ │ │ └── SKILL.md\n│ │ ├── smoke-tests\n│ │ │ └── SKILL.md\n│ │ ├── symbolicate-crash-dump\n│ │ │ └── SKILL.md\n│ │ ├── tool-rename-deprecation\n│ │ │ └── SKILL.md\n│ │ ├── unit-tests\n│ │ │ └── SKILL.md\n│ │ ├── update-screenshots\n│ │ │ └── SKILL.md\n│ │ ├── ux-css-layout\n│ │ │ └── SKILL.md\n│ │ ├── ux-theming\n│ │ │ └── SKILL.md\n│ │ └── vscode-dev-workbench\n│ │ └── SKILL.md\n│ ├── workflows\n│ │ ├── node_modules_cache\n│ │ │ ├── cache.ps1\n│ │ │ ├── cache.sh\n│ │ │ └── README.md\n│ │ ├── chat-lib-package.yml\n│ │ ├── chat-perf.yml\n│ │ ├── check-clean-git-state.sh\n│ │ ├── component-fixtures.yml\n│ │ ├── copilot-setup-steps.yml\n│ │ ├── css-order-scan.yml\n│ │ ├── monaco-editor.yml\n│ │ ├── no-engineering-system-changes.yml\n│ │ ├── pr-darwin-test.yml\n│ │ ├── pr-linux-cli-test.yml\n│ │ ├── pr-linux-test.yml\n│ │ ├── pr-node-modules.yml\n│ │ ├── pr-win32-test.yml\n│ │ ├── pr.yml\n│ │ ├── require-commit-trailer.yml\n│ │ ├── sessions-e2e.yml\n│ │ └── telemetry.yml\n│ ├── classifier.json\n│ ├── CODENOTIFY\n│ ├── CODEOWNERS\n│ ├── commands.json\n│ ├── copilot-instructions.md\n│ ├── dependabot.yml\n│ ├── insiders.yml\n│ ├── pull_request_template.md\n│ └── similarity.yml\n├── .vscode\n│ ├── extensions\n│ │ ├── vscode-extras\n│ │ │ ├── src\n│ │ │ │ ├── extension.ts\n│ │ │ │ └── npmUpToDateFeature.ts\n│ │ │ ├── package-lock.json\n│ │ │ ├── package.json\n│ │ │ └── tsconfig.json\n│ │ ├── vscode-pr-pinger\n│ │ │ ├── src\n│ │ │ │ └── extension.ts\n│ │ │ ├── .vscodeignore\n│ │ │ ├── package-lock.json\n│ │ │ ├── package.json\n│ │ │ └── tsconfig.json\n│ │ ├── vscode-selfhost-import-aid\n│ │ │ ├── .vscode\n│ │ │ │ ├── launch.json\n│ │ │ │ └── settings.json\n│ │ │ ├── src\n│ │ │ │ └── extension.ts\n│ │ │ ├── package-lock.json\n│ │ │ ├── package.json\n│ │ │ └── tsconfig.json\n│ │ └── vscode-selfhost-test-provider\n│ │ ├── .vscode\n│ │ │ ├── launch.json\n│ │ │ └── settings.json\n│ │ ├── src\n│ │ │ ├── coverageProvider.ts\n│ │ │ ├── debounce.ts\n│ │ │ ├── extension.ts\n│ │ │ ├── failingDeepStrictEqualAssertFixer.ts\n│ │ │ ├── failureTracker.ts\n│ │ │ ├── importGraph.ts\n│ │ │ ├── memoize.ts\n│ │ │ ├── metadata.ts\n│ │ │ ├── snapshot.ts\n│ │ │ ├── sourceUtils.ts\n│ │ │ ├── stackTraceParser.ts\n... (20366 more entries omitted)",
"main_features": [
"The Repository",
"Visual Studio Code",
"Feedback",
"Related Projects",
"Bundled Extensions",
"Development Container",
"Code of Conduct"
],
"metadata": {
"owner": "microsoft",
"default_branch": "main",
"topics": [
"editor",
"electron",
"microsoft",
"typescript",
"visual-studio-code"
]
}
}
\ No newline at end of file
{
"repo_name": "pytorch",
"repo_url": "https://github.com/pytorch/pytorch",
"stars": 101788,
"primary_language": "Python",
"updated_at": "2026-07-13T08:07:53Z",
"readme_text": "<picture>\n <source media=\"(prefers-color-scheme: dark)\" srcset=\"https://github.com/pytorch/pytorch/raw/main/docs/source/_static/img/pytorch-logo-light.png\" />\n <source media=\"(prefers-color-scheme: light)\" srcset=\"https://github.com/pytorch/pytorch/raw/main/docs/source/_static/img/pytorch-logo-dark.png\" />\n <img src=\"https://github.com/pytorch/pytorch/raw/main/docs/source/_static/img/pytorch-logo-dark.png\" alt=\"PyTorch logo\" />\n</picture>\n\n--------------------------------------------------------------------------------\n\nPyTorch is a Python package that provides two high-level features:\n- Tensor computation (like NumPy) with strong GPU acceleration\n- Deep neural networks built on a tape-based autograd system\n\nYou can reuse your favorite Python packages such as NumPy, SciPy, and Cython to extend PyTorch when needed.\n\nOur trunk health (Continuous Integration signals) can be found at [hud.pytorch.org](https://hud.pytorch.org/ci/pytorch/pytorch/main).\n\n<!-- toc -->\n\n- [More About PyTorch](#more-about-pytorch)\n - [A GPU-Ready Tensor Library](#a-gpu-ready-tensor-library)\n - [Dynamic Neural Networks: Tape-Based Autograd](#dynamic-neural-networks-tape-based-autograd)\n - [Python First](#python-first)\n - [Imperative Experiences](#imperative-experiences)\n - [Fast and Lean](#fast-and-lean)\n - [Extensions Without Pain](#extensions-without-pain)\n- [Installation](#installation)\n - [Binaries](#binaries)\n - [NVIDIA Jetson Platforms](#nvidia-jetson-platforms)\n - [From Source](#from-source)\n - [Prerequisites](#prerequisites)\n - [NVIDIA CUDA Support](#nvidia-cuda-support)\n - [AMD ROCm Support](#amd-rocm-support)\n - [Intel GPU Support](#intel-gpu-support)\n - [Get the PyTorch Source](#get-the-pytorch-source)\n - [Install Dependencies](#install-dependencies)\n - [Install PyTorch](#install-pytorch)\n - [Adjust Build Options (Optional)](#adjust-build-options-optional)\n - [Docker Image](#docker-image)\n - [Using pre-built images](#using-pre-built-images)\n - [Building the image yourself](#building-the-image-yourself)\n - [Building the Documentation](#building-the-documentation)\n - [Troubleshooting CI Errors](#troubleshooting-ci-errors)\n - [Building a PDF](#building-a-pdf)\n - [Previous Versions](#previous-versions)\n- [Getting Started](#getting-started)\n- [Resources](#resources)\n- [Communication](#communication)\n- [Releases and Contributing](#releases-and-contributing)\n- [The Team](#the-team)\n- [License](#license)\n\n<!-- tocstop -->\n\n## More About PyTorch\n\n[Learn the basics of PyTorch](https://pytorch.org/tutorials/beginner/basics/intro.html)\n\nAt a granular level, PyTorch is a library that consists of the following components:\n\n| Component | Description |\n| ---- | --- |\n| [**torch**](https://pytorch.org/docs/stable/torch.html) | A Tensor library like NumPy, with strong GPU support |\n| [**torch.autograd**](https://pytorch.org/docs/stable/autograd.html) | A tape-based automatic differentiation library that supports all differentiable Tensor operations in torch |\n| [**torch.jit**](https://pytorch.org/docs/stable/jit.html) | A compilation stack (TorchScript) to create serializable and optimizable models from PyTorch code |\n| [**torch.nn**](https://pytorch.org/docs/stable/nn.html) | A neural networks library deeply integrated with autograd designed for maximum flexibility |\n| [**torch.multiprocessing**](https://pytorch.org/docs/stable/multiprocessing.html) | Python multiprocessing, but with magical memory sharing of torch Tensors across processes. Useful for data loading and Hogwild training |\n| [**torch.utils**](https://pytorch.org/docs/stable/data.html) | DataLoader and other utility functions for convenience |\n\nUsually, PyTorch is used either as:\n\n- A replacement for NumPy to use the power of GPUs.\n- A deep learning research platform that provides maximum flexibility and speed.\n\nElaborating Further:\n\n### A GPU-Ready Tensor Library\n\nIf you use NumPy, then you have used Tensors (a.k.a. ndarray).\n\n![Tensor illustration](https://github.com/pytorch/pytorch/raw/main/docs/source/_static/img/tensor_illustration.png)\n\nPyTorch provides Tensors that can live either on the CPU or the GPU and accelerates the\ncomputation by a huge amount.\n\nWe provide a wide variety of tensor routines to accelerate and fit your scientific computation needs\nsuch as slicing, indexing, mathematical operations, linear algebra, reductions.\nAnd they are fast!\n\n### Dynamic Neural Networks: Tape-Based Autograd\n\nPyTorch has a unique way of building neural networks: using and replaying a tape recorder.\n\nMost frameworks such as TensorFlow, Theano, Caffe, and CNTK have a static view of the world.\nOne has to build a neural network and reuse the same structure again and again.\nChanging the way the network behaves means that one has to start from scratch.\n\nWith PyTorch, we use a technique called reverse-mode auto-differentiation, which allows you to\nchange the way your network behaves arbitrarily with zero lag or overhead. Our inspiration comes\nfrom several research papers on this topic, as well as current and past work such as\n[torch-autograd](https://github.com/twitter/torch-autograd),\n[autograd](https://github.com/HIPS/autograd),\n[Chainer](https://chainer.org), etc.\n\nWhile this technique is not unique to PyTorch, it's one of the fastest implementations of it to date.\nYou get the best of speed and flexibility for your crazy research.\n\n![Dynamic graph](https://github.com/pytorch/pytorch/raw/main/docs/source/_static/img/dynamic_graph.gif)\n\n### Python First\n\nPyTorch is not a Python binding into a monolithic C++ framework.\nIt is built to be deeply integrated into Python.\nYou can use it naturally like you would use [NumPy](https://www.numpy.org/) / [SciPy](https://www.scipy.org/) / [scikit-learn](https://scikit-learn.org) etc.\nYou can write your new neural network layers in Python itself, using your favorite libraries\nand use packages such as [Cython](https://cython.org/) and [Numba](http://numba.pydata.org/).\nOur goal is to not reinvent the wheel where appropriate.\n\n### Imperative Experiences\n\nPyTorch is designed to be intuitive, linear in thought, and easy to use.\nWhen you execute a line of code, it gets executed. There isn't an asynchronous view of the world.\nWhen you drop into a debugger or receive error messages and stack traces, understanding them is straightforward.\nThe stack trace points to exactly where your code was defined.\nWe hope you never spend hours debugging your code because of bad stack traces or asynchronous and opaque execution engines.\n\n### Fast and Lean\n\nPyTorch has minimal framework overhead. We integrate acceleration libraries\nsuch as [Intel MKL](https://software.intel.com/mkl) and NVIDIA ([cuDNN](https://developer.nvidia.com/cudnn), [NCCL](https://developer.nvidia.com/nccl)) to maximize speed.\nAt the core, its CPU and GPU Tensor and neural network backends\nare mature and have been tested for years.\n\nHence, PyTorch is quite fast — whether you run small or large neural networks.\n\nThe memory usage in PyTorch is extremely efficient compared to Torch or some of the alternatives.\nWe've written custom memory allocators for the GPU to make sure that\nyour deep learning models are maximally memory efficient.\nThis enables you to train bigger deep learning models than before.\n\n### Extensions Without Pain\n\nWriting new neural network modules, or interfacing with PyTorch's Tensor API, was designed to be straightforward\nand with minimal abstractions.\n\nYou can write new neural network layers in Python using the torch API\n[or your favorite NumPy-based libraries such as SciPy](https://pytorch.org/tutorials/advanced/numpy_extensions_tutorial.html).\n\nIf you want to write your layers in C/C++, we provide a convenient extension API that is efficient and with minimal boilerplate.\nNo wrapper code needs to be written. You can see [a tutorial here](https://pytorch.org/tutorials/advanced/cpp_extension.html) and [an example here](https://github.com/pytorch/extension-cpp).\n\n\n## Installation\n\n### Binaries\nCommands to install binaries via Conda or pip wheels are on our website: [https://pytorch.org/get-started/locally/](https://pytorch.org/get-started/locally/)\n\n\n#### NVIDIA Jetson Platforms\n\nPython wheels for NVIDIA's Jetson Nano, Jetson TX1/TX2, Jetson Xavier NX/AGX, and Jetson AGX Orin are provided [here](https://forums.developer.nvidia.com/t/pytorch-for-jetson-version-1-10-now-available/72048) and the L4T container is published [here](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/l4t-pytorch)\n\nThey require JetPack 4.2 and above, and [@dusty-nv](https://github.com/dusty-nv) and [@ptrblck](https://github.com/ptrblck) are maintaining them.\n\n\n### From Source\n\n#### Prerequisites\nIf you are installing from source, you will need:\n- Python 3.10 or later\n- A compiler that fully supports C++20, such as clang or gcc (gcc 11.3.0 or newer is required, on Linux)\n- Visual Studio or Visual Studio Build Tool (Windows only)\n- At least 10 GB of free disk space\n- 30-60 minutes for the initial build (subsequent rebuilds are much faster)\n\n\\* PyTorch CI uses Visual C++ BuildTools, which come with Visual Studio Enterprise,\nProfessional, or Community Editions. You can also install the build tools from\nhttps://visualstudio.microsoft.com/visual-cpp-build-tools/. The build tools *do not*\ncome with Visual Studio Code by default.\n\nAn example of environment setup is shown below:\n\n* Linux:\n\n```bash\n$ source <CONDA_INSTALL_DIR>/bin/activate\n$ conda create -y -n <CONDA_NAME>\n$ conda activate <CONDA_NAME>\n```\n* Windows:\n\n```bash\n$ source <CONDA_INSTALL_DIR>\\Scripts\\activate.bat\n$ conda create -y -n <CONDA_NAME>\n$ conda activate <CONDA_NAME>\n$ call \"C:\\Program Files\\Microsoft Visual Studio\\<VERSION>\\Community\\VC\\Auxiliary\\Build\\vcvarsall.bat\" x64\n```\n\nA conda environment is not required. You can also do a PyTorch build in a\nstandard virtual environment, e.g., created with tools like `uv`, provided\nyour system has installed all the necessary dependencies unavailable as pip\npackages (e.g., CUDA, MKL.)\n\n##### NVIDIA CUDA Support\nIf you want to compile with CUDA support, [select a supported version of CUDA from our support matrix](https://pytorch.org/get-started/locally/), then install the following:\n- [NVIDIA CUDA](https://developer.nvidia.com/cuda-downloads)\n- [NVIDIA cuDNN](https://developer.nvidia.com/cudnn) v9.0 or above\n- [Compiler](https://gist.github.com/ax3l/9489132) compatible with CUDA\n\nNote: You could refer to the [cuDNN Support Matrix](https://docs.nvidia.com/deeplearning/cudnn/backend/latest/reference/support-matrix.html) for cuDNN versions with the various supported CUDA, CUDA driver, and NVIDIA hardware.\n\nIf you want to disable CUDA support, export the environment variable `USE_CUDA=0`.\nOther potentially useful environment variables may be found in `setup.py`. If\nCUDA is installed in a non-standard location, set PATH so that the nvcc you\nwant to use can be found (e.g., `export PATH=/usr/local/cuda-12.8/bin:$PATH`).\n\nIf you are building for NVIDIA's Jetson platforms (Jetson Nano, TX1, TX2, AGX Xavier), Instructions to install PyTorch for Jetson Nano are [available here](https://devtalk.nvidia.com/default/topic/1049071/jetson-nano/pytorch-for-jetson-nano/)\n\n##### AMD ROCm Support\nIf you want to compile with ROCm support, install\n- [AMD ROCm](https://rocm.docs.amd.com/en/latest/deploy/linux/quick_start.html) 4.0 and above installation\n- ROCm is currently supported only for Linux systems.\n\nBy default the build system expects ROCm to be installed in `/opt/rocm`. If ROCm is installed in a different directory, the `ROCM_PATH` environment variable must be set to the ROCm installation directory. The build system automatically detects the AMD GPU architecture. Optionally, the AMD GPU architecture can be explicitly set with the `PYTORCH_ROCM_ARCH` environment variable [AMD GPU architecture](https://rocm.docs.amd.com/projects/install-on-linux/en/latest/reference/system-requirements.html#supported-gpus)\n\nIf you want to disable ROCm support, export the environment variable `USE_ROCM=0`.\nOther potentially useful environment variables may be found in `setup.py`.\n\n##### Intel GPU Support\nIf you want to compile with Intel GPU support, follow these\n- [PyTorch Prerequisites for Intel GPUs](https://www.intel.com/content/www/us/en/developer/articles/tool/pytorch-prerequisites-for-intel-gpu.html) instructions.\n- Intel GPU is supported for Linux and Windows.\n\nIf you want to disable Intel GPU support, export the environment variable `USE_XPU=0`.\nOther potentially useful environment variables may be found in `setup.py`.\n\n#### Get the PyTorch Source\n\n```bash\ngit clone https://github.com/pytorch/pytorch\ncd pytorch\n# if you are updating an existing checkout\ngit submodule sync\ngit submodule update --init --recursive\n```\n\n#### Install Dependencies\n\n**Common**\n\n```bash\n# Run this command from the PyTorch directory after cloning the source code using the “Get the PyTorch Source“ section above\npip install --group dev\n```\n\n**On Linux**\n\n```bash\npip install mkl-static mkl-include\n# CUDA only: Add LAPACK support for the GPU if needed\n# magma installation: run with active conda environment. specify CUDA version to install\n.ci/docker/common/install_magma_conda.sh 12.4\n\n# (optional) If using torch.compile with inductor/triton, install the matching version of triton\n# Run from the pytorch directory after cloning\n# For Intel GPU support, please explicitly `export USE_XPU=1` before running command.\nmake triton\n```\n\n**On Windows**\n\n```bash\npip install mkl-static mkl-include\n# Add these packages if torch.distributed is needed.\n# Distributed package support on Windows is a prototype feature and is subject to changes.\nconda install -c conda-forge libuv=1.51\n```\n\n#### Install PyTorch\n\n**On Linux**\n\nIf you're compiling for AMD ROCm then first run this command:\n\n```bash\n# Only run this if you're compiling for ROCm\npython tools/amd_build/build_amd.py\n```\n\nInstall PyTorch\n\n```bash\n# the CMake prefix for conda environment\nexport CMAKE_PREFIX_PATH=\"${CONDA_PREFIX:-'$(dirname $(which conda))/../'}:${CMAKE_PREFIX_PATH}\"\npython -m pip install --no-build-isolation -v -e .\n\n# the CMake prefix for non-conda environment, e.g. Python venv\n# call following after activating the venv\nexport CMAKE_PREFIX_PATH=\"${VIRTUAL_ENV}:${CMAKE_PREFIX_PATH}\"\n```\n\n**On macOS**\n\n```bash\npython -m pip install --no-build-isolation -v -e .\n```\n\n**On Windows**\n\nIf you want to build legacy python code, please refer to [Building on legacy code and CUDA](https://github.com/pytorch/pytorch/blob/main/CONTRIBUTING.md#building-on-legacy-code-and-cuda)\n\n**CPU-only builds**\n\nIn this mode PyTorch computations will run on your CPU, not your GPU.\n\n```cmd\npython -m pip install --no-build-isolation -v -e .\n```\n\nNote on OpenMP: The desired OpenMP implementation is Intel OpenMP (iomp). In order to link against iomp, you'll need to manually download the library and set up the building environment by tweaking `CMAKE_INCLUDE_PATH` and `LIB`. The instruction [here](https://docs.pytorch.org/docs/main/notes/windows.html#building-from-source) is an example for setting up both MKL and Intel OpenMP. Without these configurations for CMake, Microsoft Visual C OpenMP runtime (vcomp) will be used.\n\n**CUDA based build**\n\nIn this mode PyTorch computations will leverage your GPU via CUDA for faster number crunching\n\n[NVTX](https://docs.nvidia.com/gameworks/content/gameworkslibrary/nvtx/nvidia_tools_extension_library_nvtx.htm) is needed to build PyTorch with CUDA.\nNVTX is a part of CUDA distributive, where it is called \"Nsight Compute\". To install it onto an already installed CUDA run CUDA installation once again and check the corresponding checkbox.\nMake sure that CUDA with Nsight Compute is installed after Visual Studio.\n\nCurrently, VS 2017 / 2019, and Ninja are supported as the generator of CMake. If `ninja.exe` is detected in `PATH`, then Ninja will be used as the default generator, otherwise, it will use VS 2017 / 2019.\n<br/> If Ninja is selected as the generator, the latest MSVC will get selected as the underlying toolchain.\n\nAdditional libraries such as\n[Magma](https://developer.nvidia.com/magma), [oneDNN, a.k.a. MKLDNN or DNNL](https://github.com/oneapi-src/oneDNN), and [Sccache](https://github.com/mozilla/sccache) are often needed. Please refer to the [installation-helper](https://github.com/pytorch/pytorch/tree/main/.ci/pytorch/win-test-helpers/installation-helpers) to install them.\n\nYou can refer to the [build_pytorch.bat](https://github.com/pytorch/pytorch/blob/main/.ci/pytorch/win-test-helpers/build_pytorch.bat) script for some other environment variables configurations\n\n```cmd\ncmd\n\n:: Set the environment variables after you have downloaded and unzipped the mkl package,\n:: else CMake would throw an error as `Could NOT find OpenMP`.\nset CMAKE_INCLUDE_PATH={Your directory}\\mkl\\include\nset LIB={Your directory}\\mkl\\lib;%LIB%\n\n:: Read the content in the previous section carefully before you proceed.\n:: [Optional] If you want to override the underlying toolset used by Ninja and Visual Studio with CUDA, please run the following script block.\n:: \"Visual Studio 2019 Developer Command Prompt\" will be run automatically.\n:: Make sure you have CMake >= 3.12 before you do this when you use the Visual Studio generator.\nset CMAKE_GENERATOR_TOOLSET_VERSION=14.27\nset DISTUTILS_USE_SDK=1\nfor /f \"usebackq tokens=*\" %i in (`\"%ProgramFiles(x86)%\\Microsoft Visual Studio\\Installer\\vswhere.exe\" -version [15^,17^) -products * -latest -property installationPath`) do call \"%i\\VC\\Auxiliary\\Build\\vcvarsall.bat\" x64 -vcvars_ver=%CMAKE_GENERATOR_TOOLSET_VERSION%\n\n:: [Optional] If you want to override the CUDA host compiler\nset CUDAHOSTCXX=C:\\Program Files (x86)\\Microsoft Visual Studio\\2019\\Community\\VC\\Tools\\MSVC\\14.27.29110\\bin\\HostX64\\x64\\cl.exe\n\npython -m pip install --no-build-isolation -v -e .\n```\n\n**Intel GPU builds**\n\nIn this mode PyTorch with Intel GPU support will be built.\n\nPlease make sure [the common prerequisites](#prerequisites) as well as [the prerequisites for Intel GPU](#intel-gpu-support) are properly installed and the environment variables are configured prior to starting the build. For build tool support, `Visual Studio 2022` is required.\n\nThen PyTorch can be built with the command:\n\n```cmd\n:: CMD Commands:\n:: Set the CMAKE_PREFIX_PATH to help find corresponding packages\n:: %CONDA_PREFIX% only works after `conda activate custom_env`\n\nif defined CMAKE_PREFIX_PATH (\n set \"CMAKE_PREFIX_PATH=%CONDA_PREFIX%\\Library;%CMAKE_PREFIX_PATH%\"\n) else (\n set \"CMAKE_PREFIX_PATH=%CONDA_PREFIX%\\Library\"\n)\n\npython -m pip install --no-build-isolation -v -e .\n```\n\n##### Adjust Build Options (Optional)\n\nYou can adjust the configuration of cmake variables optionally (without building first), by doing\nthe following. For example, adjusting the pre-detected directories for CuDNN or BLAS can be done\nwith such a step.\n\nOn Linux\n\n```bash\nexport CMAKE_PREFIX_PATH=\"${CONDA_PREFIX:-'$(dirname $(which conda))/../'}:${CMAKE_PREFIX_PATH}\"\nCMAKE_ONLY=1 python setup.py build\nccmake build # or cmake-gui build\n```\n\nOn macOS\n\n```bash\nexport CMAKE_PREFIX_PATH=\"${CONDA_PREFIX:-'$(dirname $(which conda))/../'}:${CMAKE_PREFIX_PATH}\"\nMACOSX_DEPLOYMENT_TARGET=11.0 CMAKE_ONLY=1 python setup.py build\nccmake build # or cmake-gui build\n```\n\n### Docker Image\n\n#### Using pre-built images\n\nYou can also pull a pre-built docker image from Docker Hub and run with docker v23.0+\n\n```bash\ndocker run --gpus all --rm -ti --ipc=host pytorch/pytorch:latest\n```\n\nPlease note that PyTorch uses shared memory to share data between processes, so if torch multiprocessing is used (e.g.\nfor multithreaded data loaders) the default shared memory segment size that container runs with is not enough, and you\nshould increase shared memory size either with `--ipc=host` or `--shm-size` command line options to `nvidia-docker run`.\n\n#### Building the image yourself\n\n**NOTE:** Must be built with a Docker version >= 23.0\n\nThe Dockerfile is supplied to build images with CUDA 12.1 support and cuDNN v9.\nYou can pass `PYTHON_VERSION=x.y` make variable to specify which Python version is to be used by Miniconda, or leave it\nunset to use the default, as the Dockerfile uses system Python.\n\n```bash\nmake -f docker.Makefile\n# images are tagged as docker.io/${your_docker_username}/pytorch\n```\n\nYou can also pass the `CMAKE_VARS=\"...\"` environment variable to specify additional CMake variables to be passed to CMake during the build.\nSee [setup.py](./setup.py) for the list of available variables.\n\n```bash\nmake -f docker.Makefile\n```\n\n### Building the Documentation\n\nTo build documentation in various formats, you will need [Sphinx](http://www.sphinx-doc.org)\nand the `pytorch_sphinx_theme2`.\n\nBefore you build the documentation locally, ensure `torch` is\ninstalled in your environment. For small fixes, you can install the\nnightly version as described in [Getting Started](https://pytorch.org/get-started/locally/).\n\nFor more complex fixes, such as adding a new module and docstrings for\nthe new module, you might need to install torch [from source](#from-source).\nSee [Docstring Guidelines](https://github.com/pytorch/pytorch/wiki/Docstring-Guidelines)\nfor docstring conventions.\n\n```bash\ncd docs/\npip install -r requirements.txt\nmake html\nmake serve\n```\n\nRun `make` to get a list of all available output formats.\n\nIf you get a katex error run `npm install katex`. If it persists, try\n`npm install -g katex`\n\n> [!NOTE]\n> If you see a numpy incompatibility error, run:\n> ```\n> pip install 'numpy<2'\n> ```\n\n\n#### Troubleshooting CI Errors\nYour build may show errors you didn't have locally - here's how to find the errors relevant to the docs.\n\nIf the build has any errors, you will see something like this on the PR:\n\n<img width=\"781\" height=\"400\" alt=\"Monosnap Update installation instructions for doc build · Pull Request #169534 · pytorch:pytorch 2025-12-18 18-22-53\" src=\"https://github.com/user-attachments/assets/49a3dfe7-81c2-4246-852b-bc3f807e95af\" />\n\nAny doc-related errors will occur in jobs that include \"doc\" somewhere in the title. It doesn't look like any of these jobs are relevant to our docs.\n\n\nLet's take a look anyway. Click on the job to see the logs:\n\n<img width=\"1187\" height=\"668\" alt=\"Monosnap Update installation instructions for doc build · pytorch:pytorch@7380336 2025-12-18 18-24-15\" src=\"https://github.com/user-attachments/assets/117df543-8356-4323-8e1c-ef02a95554ba\" />\n\nAnd we can be sure that this job does not involve docs.\n\nLooking at this build, we can see these jobs are relevant to our docs - and they didn't have any errors:\n\n<img width=\"777\" height=\"395\" alt=\"Check the docs jobs\" src=\"https://github.com/user-attachments/assets/5d7c196b-2d40-49ad-87e3-f57de6e14a5b\" />\n\nYou might also see a comment on the PR like this:\n\n<img width=\"651\" height=\"246\" alt=\"PR Comment\" src=\"https://github.com/user-attachments/assets/27e0120a-ba33-4b1c-b4a5-bf3064520586\" />\n\nWe can see that some of these issues are relevant to our docs.\n\nOpen the logs by clicking on the `gh` link:\n\n<img width=\"873\" height=\"360\" alt=\"View Logs\" src=\"https://github.com/user-attachments/assets/ab5b862f-8026-489c-b95e-a6cd4257e4b7\" />\n\nAnd here we can see there is a doc-related error:\n\n<img width=\"1117\" height=\"433\" alt=\"Doc Error\" src=\"https://github.com/user-attachments/assets/0a275921-736d-43a7-ab0f-3e8854d43280\" />\n\nYou can always find the relevant doc builds by going to the `Checks` tab on your PR, and scrolling down to `pull`.\n\n<img width=\"481\" height=\"561\" alt=\"checks\" src=\"https://github.com/user-attachments/assets/eef18f2b-7134-4e2e-bd90-bcdc12800132\" />\n\nYou can either click through or toggle the accordion to see all of the jobs here, where you can see the docs jobs highlighted:\n\n<img width=\"570\" height=\"611\" alt=\"jobs\" src=\"https://github.com/user-attachments/assets/f62812ca-caee-421b-863c-54f38fd28d46\" />\n\nIf you click through, you'll see the doc jobs at the bottom, like this:\n\n<img width=\"354\" height=\"312\" alt=\"View Docs jobs\" src=\"https://github.com/user-attachments/assets/8fadb935-5314-4c4b-a1b5-133781754f03\" />\n\n\n#### Building a PDF\n\nTo compile a PDF of all PyTorch documentation, ensure you have\n`texlive` and LaTeX installed. On macOS, you can install them using:\n\n```\nbrew install --cask mactex\n```\n\nTo create the PDF:\n\n1. Run:\n\n ```\n make latexpdf\n ```\n\n This will generate the necessary files in the `build/latex` directory.\n\n2. Navigate to this directory and execute:\n\n ```\n make LATEXOPTS=\"-interaction=nonstopmode\"\n ```\n\n This will produce a `pytorch.pdf` with the desired content. Run this\n command one more time so that it generates the correct table\n of contents and index.\n\n> [!NOTE]\n> To view the Table of Contents, switch to the **Table of Contents**\n> view in your PDF viewer.\n\n\n### Previous Versions\n\nInstallation instructions and binaries for previous PyTorch versions may be found\non [our website](https://pytorch.org/get-started/previous-versions).\n\n\n## Getting Started\n\nPointers to get you started:\n- [Tutorials: get you started with understanding and using PyTorch](https://pytorch.org/tutorials/)\n- [Examples: easy to understand PyTorch code across all domains](https://github.com/pytorch/examples)\n- [The API Reference](https://pytorch.org/docs/)\n- [Glossary](https://github.com/pytorch/pytorch/blob/main/GLOSSARY.md)\n\n## Resources\n\n* [PyTorch.org](https://pytorch.org/)\n* [PyTorch Tutorials](https://pytorch.org/tutorials/)\n* [PyTorch Examples](https://github.com/pytorch/examples)\n* [PyTorch Models](https://pytorch.org/hub/)\n* [Intro to Deep Learning with PyTorch from Udacity](https://www.udacity.com/course/deep-learning-pytorch--ud188)\n* [Intro to Machine Learning with PyTorch from Udacity](https://www.udacity.com/course/intro-to-machine-learning-nanodegree--nd229)\n* [Deep Neural Networks with PyTorch from Coursera](https://www.coursera.org/learn/deep-neural-networks-with-pytorch)\n* [PyTorch Twitter](https://twitter.com/PyTorch)\n* [PyTorch Blog](https://pytorch.org/blog/)\n* [PyTorch YouTube](https://www.youtube.com/channel/UCWXI5YeOsh03QvJ59PMaXFw)\n\n## Communication\n* Forums: Discuss implementations, research, etc. https://discuss.pytorch.org\n* GitHub Issues: Bug reports, feature requests, install issues, RFCs, thoughts, etc.\n* Slack: The [PyTorch Slack](https://pytorch.slack.com/) hosts a primary audience of moderate to experienced PyTorch users and developers for general chat, online discussions, collaboration, etc. If you are a beginner looking for help, the primary medium is [PyTorch Forums](https://discuss.pytorch.org). If you need a slack invite, please fill this form: https://goo.gl/forms/PP1AGvNHpSaJP8to1\n* Newsletter: No-noise, a one-way email newsletter with important announcements about PyTorch. You can sign-up here: https://eepurl.com/cbG0rv\n* Facebook Page: Important announcements about PyTorch. https://www.facebook.com/pytorch\n* For brand guidelines, please visit our website at [pytorch.org](https://pytorch.org/)\n\n## Releases and Contributing\n\nTypically, PyTorch has three minor releases a year. Please let us know if you encounter a bug by [filing an issue](https://github.com/pytorch/pytorch/issues).\n\nWe appreciate all contributions. If you are planning to contribute back bug-fixes, please do so without any further discussion.\n\nIf you plan to contribute new features, utility functions, or extensions to the core, please first open an issue and discuss the feature with us.\nSending a PR without discussion might end up resulting in a rejected PR because we might be taking the core in a different direction than you might be aware of.\n\nTo learn more about making a contribution to PyTorch, please see our [Contribution page](CONTRIBUTING.md). For more information about PyTorch releases, see [Release page](RELEASE.md).\n\n## The Team\n\nPyTorch is a community-driven project with several skillful engineers and researchers contributing to it.\n\nPyTorch is currently maintained by [Soumith Chintala](http://soumith.ch), [Gregory Chanan](https://github.com/gchanan), [Dmytro Dzhulgakov](https://github.com/dzhulgakov), [Edward Yang](https://github.com/ezyang), [Alban Desmaison](https://github.com/albanD), [Piotr Bialecki](https://github.com/ptrblck) and [Nikita Shulga](https://github.com/malfet) with major contributions coming from hundreds of talented individuals in various forms and means.\nA non-exhaustive but growing list needs to mention: [Trevor Killeen](https://github.com/killeent), [Sasank Chilamkurthy](https://github.com/chsasank), [Sergey Zagoruyko](https://github.com/szagoruyko), [Adam Lerer](https://github.com/adamlerer), [Francisco Massa](https://github.com/fmassa), [Alykhan Tejani](https://github.com/alykhantejani), [Luca Antiga](https://github.com/lantiga), [Alban Desmaison](https://github.com/albanD), [Andreas Koepf](https://github.com/andreaskoepf), [James Bradbury](https://github.com/jekbradbury), [Zeming Lin](https://github.com/ebetica), [Yuandong Tian](https://github.com/yuandong-tian), [Guillaume Lample](https://github.com/glample), [Marat Dukhan](https://github.com/Maratyszcza), [Natalia Gimelshein](https://github.com/ngimel), [Christian Sarofeen](https://github.com/csarofeen), [Martin Raison](https://github.com/martinraison), [Edward Yang](https://github.com/ezyang), [Zachary Devito](https://github.com/zdevito). <!-- codespell:ignore -->\n\nNote: This project is unrelated to [hughperkins/pytorch](https://github.com/hughperkins/pytorch) with the same name. Hugh is a valuable contributor to the Torch community and has helped with many things Torch and PyTorch.\n\n## License\n\nPyTorch has a BSD-style license, as found in the [LICENSE](LICENSE) file.",
"directory_tree": "├── .ci\n│ ├── caffe2\n│ │ ├── common.sh\n│ │ ├── README.md\n│ │ └── test.sh\n│ ├── docker\n│ │ ├── almalinux\n│ │ │ ├── build.sh\n│ │ │ └── Dockerfile\n│ │ ├── ci_commit_pins\n│ │ │ ├── executorch.txt\n│ │ │ ├── halide.txt\n│ │ │ ├── huggingface-requirements.txt\n│ │ │ ├── jax.txt\n│ │ │ ├── nccl-cu126.txt\n│ │ │ ├── nccl.txt\n│ │ │ ├── rocm-composable-kernel.txt\n│ │ │ ├── rocm-origami.txt\n│ │ │ ├── timm.txt\n│ │ │ ├── torchbench.txt\n│ │ │ ├── triton-cpu.txt\n│ │ │ ├── triton-xpu.txt\n│ │ │ └── triton.txt\n│ │ ├── common\n│ │ │ ├── cache_vision_models.sh\n│ │ │ ├── common_utils.sh\n│ │ │ ├── install_acl.sh\n│ │ │ ├── install_amdsmi.sh\n│ │ │ ├── install_base.sh\n│ │ │ ├── install_cache.sh\n│ │ │ ├── install_clang.sh\n│ │ │ ├── install_conda.sh\n│ │ │ ├── install_conda_docker.sh\n│ │ │ ├── install_cpython.sh\n│ │ │ ├── install_cuda.sh\n│ │ │ ├── install_cudss.sh\n│ │ │ ├── install_cusparselt.sh\n│ │ │ ├── install_docs_reqs.sh\n│ │ │ ├── install_executorch.sh\n│ │ │ ├── install_gcc.sh\n│ │ │ ├── install_halide.sh\n│ │ │ ├── install_inductor_benchmark_deps.sh\n│ │ │ ├── install_jax.sh\n│ │ │ ├── install_jni.sh\n│ │ │ ├── install_lcov.sh\n│ │ │ ├── install_libgomp.sh\n│ │ │ ├── install_libpng.sh\n│ │ │ ├── install_linter.sh\n│ │ │ ├── install_magma.sh\n│ │ │ ├── install_magma_conda.sh\n│ │ │ ├── install_mingw.sh\n│ │ │ ├── install_miopen.sh\n│ │ │ ├── install_mkl.sh\n│ │ │ ├── install_mnist.sh\n│ │ │ ├── install_nccl.sh\n│ │ │ ├── install_nvpl.sh\n│ │ │ ├── install_onnx.sh\n│ │ │ ├── install_openblas.sh\n│ │ │ ├── install_openmpi.sh\n│ │ │ ├── install_patchelf.sh\n│ │ │ ├── install_python.sh\n│ │ │ ├── install_rocm.sh\n│ │ │ ├── install_rocm_drm.sh\n│ │ │ ├── install_rocm_magma.sh\n│ │ │ ├── install_rocSHMEM.sh\n│ │ │ ├── install_torch_tpu.sh\n│ │ │ ├── install_triton.sh\n│ │ │ ├── install_user.sh\n│ │ │ ├── install_xpu.sh\n│ │ │ ├── patch_libstdc.sh\n│ │ │ └── requirements_tpu.txt\n│ │ ├── java\n│ │ │ └── jni.h\n│ │ ├── linter\n│ │ │ └── Dockerfile\n│ │ ├── linter-cuda\n│ │ │ └── Dockerfile\n│ │ ├── manywheel\n│ │ │ ├── s390_scripts\n│ │ │ │ ├── build.sh\n│ │ │ │ └── build_utils.sh\n│ │ │ ├── build.sh\n│ │ │ ├── Dockerfile_2_28\n│ │ │ ├── Dockerfile_2_28_aarch64\n│ │ │ ├── Dockerfile_cuda_aarch64\n│ │ │ └── Dockerfile_s390x\n│ │ ├── ubuntu\n│ │ │ └── Dockerfile\n│ │ ├── ubuntu-cross-riscv\n│ │ │ └── Dockerfile\n│ │ ├── ubuntu-rocm\n│ │ │ ├── .gitignore\n│ │ │ └── Dockerfile\n│ │ ├── ubuntu-xpu\n│ │ │ └── Dockerfile\n│ │ ├── build.sh\n│ │ ├── README.md\n│ │ ├── requirements-ci.txt\n│ │ ├── requirements-docs.txt\n│ │ ├── triton_version.txt\n│ │ └── triton_xpu_version.txt\n│ ├── flash-attention\n│ │ └── build.sh\n│ ├── libtorch\n│ │ ├── build.sh\n│ │ └── extract_libtorch_from_wheel.py\n│ ├── lumen_cli\n│ │ ├── cli\n│ │ │ ├── build_cli\n│ │ │ │ ├── __init__.py\n│ │ │ │ └── register_build.py\n│ │ │ ├── lib\n│ │ │ │ ├── common\n│ │ │ │ │ ├── cli_helper.py\n│ │ │ │ │ ├── docker_helper.py\n│ │ │ │ │ ├── envs_helper.py\n│ │ │ │ │ ├── gh_summary.py\n│ │ │ │ │ ├── git_helper.py\n│ │ │ │ │ ├── logger.py\n│ │ │ │ │ ├── path_helper.py\n│ │ │ │ │ ├── pip_helper.py\n│ │ │ │ │ └── utils.py\n│ │ │ │ ├── core\n│ │ │ │ │ ├── torchtitan\n│ │ │ │ │ │ ├── lib.py\n│ │ │ │ │ │ ├── torchtitan_test.py\n│ │ │ │ │ │ └── torchtitan_test_library.yaml\n│ │ │ │ │ └── vllm\n│ │ │ │ │ ├── disabled_vllm_tests.yaml\n│ │ │ │ │ ├── lib.py\n│ │ │ │ │ ├── vllm_build.py\n│ │ │ │ │ ├── vllm_test.py\n│ │ │ │ │ └── vllm_test_library.yaml\n│ │ │ │ └── __init__.py\n│ │ │ ├── test_cli\n│ │ │ │ ├── __init__.py\n│ │ │ │ └── register_test.py\n│ │ │ └── run.py\n│ │ ├── tests\n│ │ │ ├── test_app.py\n│ │ │ ├── test_cli_helper.py\n│ │ │ ├── test_docker_helper.py\n│ │ │ ├── test_envs_helper.py\n│ │ │ ├── test_path_helper.py\n│ │ │ ├── test_run_plan.py\n│ │ │ ├── test_utils.py\n│ │ │ └── test_vllm.py\n│ │ ├── pyproject.toml\n│ │ └── README.md\n│ ├── macwheel\n│ │ ├── build.sh\n│ │ ├── build_all_macos_wheels.sh\n│ │ ├── build_env_setup.py\n│ │ ├── build_install_deps.py\n│ │ ├── build_wheel.py\n│ │ ├── install_libomp.sh\n│ │ └── repair_wheel.py\n│ ├── magma\n│ │ ├── package_files\n│ │ │ ├── build.sh\n│ │ │ ├── CMake.patch\n│ │ │ ├── cmakelists.patch\n│ │ │ ├── cuda13.patch\n│ │ │ ├── getrf_nbparam.patch\n│ │ │ ├── getrf_shfl.patch\n│ │ │ ├── magma-2.6.1.sha256\n│ │ │ └── thread_queue.patch\n│ │ ├── .gitignore\n│ │ ├── build_magma.sh\n│ │ ├── Makefile\n│ │ └── README.md\n│ ├── magma-rocm\n│ │ ├── package_files\n│ │ │ └── build.sh\n│ │ ├── .gitignore\n│ │ ├── build_magma.sh\n│ │ ├── Makefile\n│ │ └── README.md\n│ ├── manywheel\n│ │ ├── build.sh\n│ │ ├── build_all.sh\n│ │ ├── build_common.sh\n│ │ ├── build_cpu.sh\n│ │ ├── build_env_setup.py\n│ │ ├── build_install_deps.py\n│ │ ├── build_libtorch.sh\n│ │ ├── build_wheel.py\n│ │ ├── LICENSE\n│ │ ├── repair_wheel.py\n│ │ └── set_desired_python.sh\n│ └── pytorch\n│ ├── fake_numpy\n│ │ └── numpy.py\n│ ├── smoke_test\n│ │ ├── check_binary_symbols.py\n│ │ ├── check_gomp.py\n│ │ ├── check_wheel_tags.py\n│ │ ├── max_autotune.py\n│ │ └── smoke_test.py\n│ ├── test_example_code\n│ │ ├── check-torch-cuda.cpp\n│ │ ├── check-torch-mkl.cpp\n│ │ ├── check-torch-xnnpack.cpp\n│ │ ├── CMakeLists.txt\n│ │ ├── cnn_smoke.py\n│ │ ├── cnn_smoke_win_arm64.py\n│ │ ├── rnn_smoke.py\n│ │ ├── rnn_smoke_win_arm64.py\n│ │ └── simple-torch-test.cpp\n│ ├── win-test-helpers\n│ │ ├── arm64\n│ │ │ └── build_pytorch.ps1\n│ │ ├── installation-helpers\n│ │ │ ├── activate_miniconda3.bat\n│ │ │ ├── install_magma.bat\n│ │ │ └── install_sccache.bat\n│ │ ├── build_pytorch.bat\n│ │ ├── choose_runtime_cuda_version.bat\n│ │ ├── run_python_nn_smoketests.py\n│ │ ├── setup_pytorch_env.bat\n│ │ ├── test_custom_backend.bat\n│ │ ├── test_custom_script_ops.bat\n│ │ ├── test_distributed.bat\n│ │ ├── test_libtorch.bat\n│ │ ├── test_openreg.bat\n│ │ ├── test_python_jit_legacy.bat\n│ │ └── test_python_shard.bat\n│ ├── windows\n│ │ ├── arm64\n│ │ │ ├── bootstrap_apl.bat\n│ │ │ ├── bootstrap_buildtools.bat\n│ │ │ ├── bootstrap_git.bat\n│ │ │ ├── bootstrap_libuv.bat\n│ │ │ ├── bootstrap_openblas.bat\n│ │ │ ├── bootstrap_python.bat\n│ │ │ ├── bootstrap_rust.bat\n│ │ │ ├── bootstrap_sccache.bat\n│ │ │ ├── bootstrap_tests.bat\n│ │ │ ├── build_libtorch.bat\n│ │ │ ├── build_pytorch.bat\n│ │ │ └── smoke_test.bat\n│ │ ├── internal\n│ │ │ ├── 7z_install.bat\n│ │ │ ├── cuda_install.bat\n│ │ │ ├── driver_update.bat\n│ │ │ ├── install_python.bat\n│ │ │ ├── smoke_test.bat\n│ │ │ ├── static_lib_test.bat\n│ │ │ ├── vc_install_helper.bat\n│ │ │ ├── vs2022_install.ps1\n│ │ │ └── xpu_install.bat\n│ │ ├── _common.py\n│ │ ├── build_env_setup.py\n│ │ ├── build_install_deps.py\n│ │ ├── build_wheel.py\n│ │ └── set_desired_python.sh\n│ ├── .shellcheckrc\n│ ├── binary_linux_test.sh\n│ ├── binary_populate_env.sh\n│ ├── binary_upload.sh\n│ ├── binary_windows_build.sh\n│ ├── binary_windows_test.sh\n│ ├── build.sh\n│ ├── check_binary.sh\n│ ├── codegen-test.sh\n│ ├── common-build.sh\n│ ├── common.sh\n│ ├── common_utils.sh\n│ ├── cpp_doc_push_script.sh\n│ ├── docker-build-test.sh\n│ ├── docs-test.sh\n│ ├── install_cache_xla.sh\n│ ├── macos-build-test.sh\n│ ├── macos-build.sh\n│ ├── macos-common.sh\n│ ├── macos-test.sh\n│ ├── multigpu-test.sh\n│ ├── numba-cuda-13.patch\n│ ├── print_sccache_log.py\n│ ├── python_doc_push_script.sh\n│ ├── README.md\n│ ├── rocm_preflight.py\n│ ├── rocm_utils.sh\n│ ├── run_tests.sh\n│ ├── test.sh\n│ ├── test_fa3_abi_stable.sh\n│ ├── torch_trace.sh\n│ ├── win-arm64-build.ps1\n│ ├── win-arm64-test.sh\n│ ├── win-build.sh\n│ └── win-test.sh\n├── .claude\n│ └── skills\n│ ├── add-uint-support\n│ │ └── SKILL.md\n│ ├── aoti-debug\n│ │ ├── SKILL.md\n│ │ └── triton-index-out-of-bounds.md\n│ ├── at-dispatch-v2\n│ │ └── SKILL.md\n... (22493 more entries omitted)",
"main_features": [
"Tensor computation (like NumPy) with strong GPU acceleration",
"Deep neural networks built on a tape-based autograd system",
"A replacement for NumPy to use the power of GPUs",
"A deep learning research platform that provides maximum flexibility and speed"
],
"metadata": {
"owner": "pytorch",
"default_branch": "main",
"topics": [
"autograd",
"deep-learning",
"gpu",
"machine-learning",
"neural-network",
"numpy",
"python",
"tensor"
]
}
}
\ No newline at end of file
{
"repo_name": "llama_index",
"repo_url": "https://github.com/run-llama/llama_index",
"stars": 50809,
"primary_language": "Python",
"updated_at": "2026-07-13T07:49:18Z",
"readme_text": "# 🗂️ LlamaIndex 🦙\n\n[![PyPI - Downloads](https://img.shields.io/pypi/dm/llama-index)](https://pypi.org/project/llama-index/)\n[![Build](https://github.com/run-llama/llama_index/actions/workflows/build_package.yml/badge.svg)](https://github.com/run-llama/llama_index/actions/workflows/build_package.yml)\n[![GitHub contributors](https://img.shields.io/github/contributors/jerryjliu/llama_index)](https://github.com/jerryjliu/llama_index/graphs/contributors)\n[![Discord](https://img.shields.io/discord/1059199217496772688)](https://discord.gg/dGcwcsnxhU)\n[![Twitter](https://img.shields.io/twitter/follow/llama_index)](https://x.com/llama_index)\n[![Reddit](https://img.shields.io/reddit/subreddit-subscribers/LlamaIndex?style=plastic&logo=reddit&label=r%2FLlamaIndex&labelColor=white)](https://www.reddit.com/r/LlamaIndex/)\n[![Ask AI](https://img.shields.io/badge/Phorm-Ask_AI-%23F2777A.svg?&logo=data:image/svg+xml;base64,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)](https://www.phorm.ai/query?projectId=c5863b56-6703-4a5d-87b6-7e6031bf16b6)\n\nLlamaIndex OSS (by [LlamaIndex](https://llamaindex.ai?utm_medium=li_github&utm_source=github&utm_campaign=2026--)) is an open-source framework to build agentic applications. **[Parse](https://cloud.llamaindex.ai?utm_medium=li_github&utm_source=github&utm_campaign=2026--)** is our enterprise platform for agentic OCR, parsing, extraction, indexing and more. You can use LlamaParse with this framework or on its own; see [LlamaParse](#llamacloud-document-agent-platform) below for signup and product links.\n\n> ### 📚 **Documentation:**\n>\n> - [LlamaParse](https://developers.llamaindex.ai/python/cloud/llamaparse/?utm_medium=li_github&utm_source=github&utm_campaign=2026--)\n> - [LlamaIndex OSS](https://developers.llamaindex.ai/python/framework/?utm_medium=li_github&utm_source=github&utm_campaign=2026--)\n> - [LlamaAgents](https://developers.llamaindex.ai/python/llamaagents/overview/?utm_medium=li_github&utm_source=github&utm_campaign=2026--)\n\nBuilding with LlamaIndex typically involves working with LlamaIndex core and a chosen set of integrations (or plugins). There are two ways to start building with LlamaIndex in\nPython:\n\n1. **Starter**: [`llama-index`](https://pypi.org/project/llama-index/). A starter Python package that includes core LlamaIndex as well as a selection of integrations.\n\n2. **Customized**: [`llama-index-core`](https://pypi.org/project/llama-index-core/). Install core LlamaIndex and add your chosen LlamaIndex integration packages on [LlamaHub](https://llamahub.ai/)\n that are required for your application. There are over 300 LlamaIndex integration\n packages that work seamlessly with core, allowing you to build with your preferred\n LLM, embedding, and vector store providers.\n\nThe LlamaIndex Python library is namespaced such that import statements which\ninclude `core` imply that the core package is being used. In contrast, those\nstatements without `core` imply that an integration package is being used.\n\n```python\n# typical pattern\nfrom llama_index.core.xxx import ClassABC # core submodule xxx\nfrom llama_index.xxx.yyy import (\n SubclassABC,\n) # integration yyy for submodule xxx\n\n# concrete example\nfrom llama_index.core.llms import LLM\nfrom llama_index.llms.openai import OpenAI\n```\n\n### LlamaParse (document agent platform)\n\n**LlamaParse** is its own platform—focused on document agents and agentic OCR. It includes **Parse** (parsing), **LlamaAgents** (deployed document agents), **Extract** (structured extraction), and **Index** (ingest and RAG). You can use it with the LlamaIndex framework or standalone.\n\n- **[Sign up for LlamaParse](https://cloud.llamaindex.ai?utm_medium=li_github&utm_source=github&utm_campaign=2026--)** — Create an account and get your API key.\n- **Parse** — Agentic OCR and document parsing (130+ formats). [Docs](https://developers.llamaindex.ai/python/cloud/llamaparse/?utm_medium=li_github&utm_source=github&utm_campaign=2026--)\n- **Extract** — Structured data extraction from documents. [Docs](https://developers.llamaindex.ai/python/cloud/llamaextract/?utm_medium=li_github&utm_source=github&utm_campaign=2026--)\n- **Index** — Ingest, index, and RAG pipelines. [Docs](https://developers.llamaindex.ai/python/cloud/llamacloud/?utm_medium=li_github&utm_source=github&utm_campaign=2026--)\n- **Split** — Split large documents into subcategories. [Docs](https://developers.llamaindex.ai/python/cloud/split/getting_started/?utm_medium=li_github&utm_source=github&utm_campaign=2026--)\n- **Agents** — Build end-to-end document agents with `Workflows` and Agent Builder. [Docs](https://developers.llamaindex.ai/python/llamaagents/overview/?utm_medium=li_github&utm_source=github&utm_campaign=2026--)\n\n### Important Links\n\n[Documentation](https://developers.llamaindex.ai/python/framework/?utm_medium=li_github&utm_source=github&utm_campaign=2026--)\n\n[X (formerly Twitter)](https://x.com/llama_index)\n\n[LinkedIn](https://www.linkedin.com/company/llamaindex/)\n\n[Reddit](https://www.reddit.com/r/LlamaIndex/)\n\n[Discord](https://discord.gg/dGcwcsnxhU)\n\n## 🚀 Overview\n\n**NOTE**: This README is not updated as frequently as the documentation. Please check out the documentation above for the latest updates!\n\n### Context\n\n- LLMs are a phenomenal piece of technology for knowledge generation and reasoning. They are pre-trained on large amounts of publicly available data.\n- How do we best augment LLMs with our own private data?\n\nWe need a comprehensive toolkit to help perform this data augmentation for LLMs.\n\n### Proposed Solution\n\nThat's where **LlamaIndex** comes in. LlamaIndex is a \"data framework\" to help you build LLM apps. It provides the following tools:\n\n- Offers **data connectors** to ingest your existing data sources and data formats (APIs, PDFs, docs, SQL, etc.).\n- Provides ways to **structure your data** (indices, graphs) so that this data can be easily used with LLMs.\n- Provides an **advanced retrieval/query interface over your data**: Feed in any LLM input prompt, get back retrieved context and knowledge-augmented output.\n- Allows easy integrations with your outer application framework (e.g. with LangChain, Flask, Docker, ChatGPT, or anything else).\n\nLlamaIndex provides tools for both beginner users and advanced users. Our high-level API allows beginner users to use LlamaIndex to ingest and query their data in\n5 lines of code. Our lower-level APIs allow advanced users to customize and extend any module (data connectors, indices, retrievers, query engines, reranking modules),\nto fit their needs.\n\n## 💡 Contributing\n\nInterested in contributing? Contributions to LlamaIndex core as well as contributing\nintegrations that build on the core are both accepted and highly encouraged! See our [Contribution Guide](CONTRIBUTING.md) for more details.\n\nNew integrations should meaningfully integrate with existing LlamaIndex framework components. At the discretion of LlamaIndex maintainers, some integrations may be declined.\n\n## 📄 Documentation\n\nFull documentation can be found [here](https://developers.llamaindex.ai/python/framework/?utm_medium=li_github&utm_source=github&utm_campaign=2026--)\n\nPlease check it out for the most up-to-date tutorials, how-to guides, references, and other resources!\n\n## 💻 Example Usage\n\n```sh\n# custom selection of integrations to work with core\npip install llama-index-core\npip install llama-index-llms-openai\npip install llama-index-llms-ollama\npip install llama-index-embeddings-huggingface\n```\n\nExamples are in the `docs/examples` folder. Indices are in the `indices` folder (see list of indices below).\n\nTo build a simple vector store index using OpenAI:\n\n```python\nimport os\n\nos.environ[\"OPENAI_API_KEY\"] = \"YOUR_OPENAI_API_KEY\"\n\nfrom llama_index.core import VectorStoreIndex, SimpleDirectoryReader\n\ndocuments = SimpleDirectoryReader(\"YOUR_DATA_DIRECTORY\").load_data()\nindex = VectorStoreIndex.from_documents(documents)\n```\n\nTo build a simple vector store index using non-OpenAI LLMs, e.g. LLMs hosted through Ollama:\n\n```python\nfrom llama_index.core import Settings, VectorStoreIndex, SimpleDirectoryReader\nfrom llama_index.embeddings.huggingface import HuggingFaceEmbedding\nfrom llama_index.llms.ollama import Ollama\nfrom transformers import AutoTokenizer\n\n# set the LLM\nSettings.llm = Ollama(\n model=\"llama-3.1:latest\",\n request_timeout=360.0,\n)\n\n# set tokenizer to match LLM\nSettings.tokenizer = AutoTokenizer.from_pretrained(\n \"meta-llama/Llama-3.1-8B-Instruct\"\n)\n\n# set the embed model\nSettings.embed_model = HuggingFaceEmbedding(\n model_name=\"BAAI/bge-small-en-v1.5\"\n)\n\ndocuments = SimpleDirectoryReader(\"YOUR_DATA_DIRECTORY\").load_data()\nindex = VectorStoreIndex.from_documents(\n documents,\n)\n```\n\nTo query:\n\n```python\nquery_engine = index.as_query_engine()\nquery_engine.query(\"YOUR_QUESTION\")\n```\n\nBy default, data is stored in-memory.\nTo persist to disk (under `./storage`):\n\n```python\nindex.storage_context.persist()\n```\n\nTo reload from disk:\n\n```python\nfrom llama_index.core import StorageContext, load_index_from_storage\n\n# rebuild storage context\nstorage_context = StorageContext.from_defaults(persist_dir=\"./storage\")\n# load index\nindex = load_index_from_storage(storage_context)\n```\n\n## A note on Verification of Build Assets\n\nBy default, `llama-index-core` includes a `_static` folder that contains the nltk and tiktoken cache that is included with the package installation. This ensures that you can easily run `llama-index` in environments with restrictive disk access permissions at runtime.\n\nTo verify that these files are safe and valid, we use the github `attest-build-provenance` action. This action will verify that the files in the `_static` folder are the same as the files in the `llama-index-core/llama_index/core/_static` folder.\n\nTo verify this, you can run the following script (pointing to your installed package):\n\n```bash\n#!/bin/bash\nSTATIC_DIR=\"venv/lib/python3.13/site-packages/llama_index/core/_static\"\nREPO=\"run-llama/llama_index\"\n\nfind \"$STATIC_DIR\" -type f | while read -r file; do\n echo \"Verifying: $file\"\n gh attestation verify \"$file\" -R \"$REPO\" || echo \"Failed to verify: $file\"\ndone\n```\n\n## 📖 Citation\n\nReference to cite if you use LlamaIndex in a paper:\n\n```\n@software{Liu_LlamaIndex_2022,\nauthor = {Liu, Jerry},\ndoi = {10.5281/zenodo.1234},\nmonth = {11},\ntitle = {{LlamaIndex}},\nurl = {https://github.com/jerryjliu/llama_index},\nyear = {2022}\n}\n```",
"directory_tree": "├── .github\n│ ├── ISSUE_TEMPLATE\n│ │ ├── config.yml\n│ │ ├── docs-form.yml\n│ │ ├── feature-form.yml\n│ │ ├── issue-form.yml\n│ │ └── question-form.yml\n│ ├── workflows\n│ │ ├── build_package.yml\n│ │ ├── close_new_integration_prs.yml\n│ │ ├── codeql.yml\n│ │ ├── core-typecheck.yml\n│ │ ├── coverage_check.yml\n│ │ ├── issue_classifier.yml\n│ │ ├── lint.yml\n│ │ ├── llama_dev_tests.yml\n│ │ ├── pre_release.yml\n│ │ ├── publish_sub_package.yml\n│ │ ├── release.yml\n│ │ ├── stale_bot.yml\n│ │ ├── sync-docs.yml\n│ │ └── unit_test.yml\n│ ├── dependabot.yml\n│ └── pull_request_template.md\n├── docs\n│ ├── api_reference\n│ │ ├── api_reference\n│ │ │ ├── _static\n│ │ │ │ └── assets\n│ │ │ │ ├── LlamaLogoBrowserTab.png\n│ │ │ │ └── LlamaSquareBlack.svg\n│ │ │ ├── agent\n│ │ │ │ └── index.md\n│ │ │ ├── callbacks\n│ │ │ │ ├── agentops.md\n│ │ │ │ ├── aim.md\n│ │ │ │ ├── argilla.md\n│ │ │ │ ├── arize_phoenix.md\n│ │ │ │ ├── honeyhive.md\n│ │ │ │ ├── index.md\n│ │ │ │ ├── langfuse.md\n│ │ │ │ ├── literalai.md\n│ │ │ │ ├── llama_debug.md\n│ │ │ │ ├── openinference.md\n│ │ │ │ ├── opik.md\n│ │ │ │ ├── promptlayer.md\n│ │ │ │ ├── token_counter.md\n│ │ │ │ ├── uptrain.md\n│ │ │ │ └── wandb.md\n│ │ │ ├── chat_engines\n│ │ │ │ ├── condense_plus_context.md\n│ │ │ │ ├── condense_question.md\n│ │ │ │ ├── context.md\n│ │ │ │ ├── index.md\n│ │ │ │ └── simple.md\n│ │ │ ├── embeddings\n│ │ │ │ ├── adapter.md\n│ │ │ │ ├── alephalpha.md\n│ │ │ │ ├── alibabacloud_aisearch.md\n│ │ │ │ ├── anyscale.md\n│ │ │ │ ├── autoembeddings.md\n│ │ │ │ ├── azure_inference.md\n│ │ │ │ ├── azure_openai.md\n│ │ │ │ ├── baseten.md\n│ │ │ │ ├── bedrock.md\n│ │ │ │ ├── clarifai.md\n│ │ │ │ ├── clip.md\n│ │ │ │ ├── cloudflare_workersai.md\n│ │ │ │ ├── cohere.md\n│ │ │ │ ├── dashscope.md\n│ │ │ │ ├── databricks.md\n│ │ │ │ ├── deepinfra.md\n│ │ │ │ ├── elasticsearch.md\n│ │ │ │ ├── fastembed.md\n│ │ │ │ ├── fireworks.md\n│ │ │ │ ├── gaudi.md\n│ │ │ │ ├── gigachat.md\n│ │ │ │ ├── google_genai.md\n│ │ │ │ ├── heroku.md\n│ │ │ │ ├── huggingface.md\n│ │ │ │ ├── huggingface_api.md\n│ │ │ │ ├── huggingface_openvino.md\n│ │ │ │ ├── huggingface_optimum.md\n│ │ │ │ ├── huggingface_optimum_intel.md\n│ │ │ │ ├── ibm.md\n│ │ │ │ ├── index.md\n│ │ │ │ ├── instructor.md\n│ │ │ │ ├── ipex_llm.md\n│ │ │ │ ├── isaacus.md\n│ │ │ │ ├── jinaai.md\n│ │ │ │ ├── langchain.md\n│ │ │ │ ├── litellm.md\n│ │ │ │ ├── llamafile.md\n│ │ │ │ ├── llm_rails.md\n│ │ │ │ ├── mistralai.md\n│ │ │ │ ├── mixedbreadai.md\n│ │ │ │ ├── modelscope.md\n│ │ │ │ ├── nebius.md\n│ │ │ │ ├── netmind.md\n│ │ │ │ ├── nomic.md\n│ │ │ │ ├── nvidia.md\n│ │ │ │ ├── oci_data_science.md\n│ │ │ │ ├── oci_genai.md\n│ │ │ │ ├── ollama.md\n│ │ │ │ ├── opea.md\n│ │ │ │ ├── openai.md\n│ │ │ │ ├── openai_like.md\n│ │ │ │ ├── openvino_genai.md\n│ │ │ │ ├── oracleai.md\n│ │ │ │ ├── premai.md\n│ │ │ │ ├── sagemaker_endpoint.md\n│ │ │ │ ├── siliconflow.md\n│ │ │ │ ├── text_embeddings_inference.md\n│ │ │ │ ├── textembed.md\n│ │ │ │ ├── together.md\n│ │ │ │ ├── upstage.md\n│ │ │ │ ├── vertex.md\n│ │ │ │ ├── vertex_endpoint.md\n│ │ │ │ ├── vllm.md\n│ │ │ │ ├── voyageai.md\n│ │ │ │ ├── xinference.md\n│ │ │ │ ├── yandexgpt.md\n│ │ │ │ └── zhipuai.md\n│ │ │ ├── evaluation\n│ │ │ │ ├── answer_relevancy.md\n│ │ │ │ ├── context_relevancy.md\n│ │ │ │ ├── correctness.md\n│ │ │ │ ├── dataset_generation.md\n│ │ │ │ ├── faithfullness.md\n│ │ │ │ ├── guideline.md\n│ │ │ │ ├── index.md\n│ │ │ │ ├── metrics.md\n│ │ │ │ ├── multi_modal.md\n│ │ │ │ ├── pairwise_comparison.md\n│ │ │ │ ├── query_response.md\n│ │ │ │ ├── response.md\n│ │ │ │ ├── retrieval.md\n│ │ │ │ ├── semantic_similarity.md\n│ │ │ │ └── tonic_validate.md\n│ │ │ ├── extractors\n│ │ │ │ ├── documentcontext.md\n│ │ │ │ ├── entity.md\n│ │ │ │ ├── index.md\n│ │ │ │ ├── keyword.md\n│ │ │ │ ├── marvin.md\n│ │ │ │ ├── pydantic.md\n│ │ │ │ ├── question.md\n│ │ │ │ ├── relik.md\n│ │ │ │ ├── summary.md\n│ │ │ │ └── title.md\n│ │ │ ├── graph_rag\n│ │ │ │ └── cognee.md\n│ │ │ ├── indices\n│ │ │ │ ├── bge_m3.md\n│ │ │ │ ├── colbert.md\n│ │ │ │ ├── dashscope.md\n│ │ │ │ ├── document_summary.md\n│ │ │ │ ├── google.md\n│ │ │ │ ├── index.md\n│ │ │ │ ├── keyword.md\n│ │ │ │ ├── knowledge_graph.md\n│ │ │ │ ├── lancedb.md\n│ │ │ │ ├── llama_cloud.md\n│ │ │ │ ├── postgresml.md\n│ │ │ │ ├── property_graph.md\n│ │ │ │ ├── summary.md\n│ │ │ │ ├── tree.md\n│ │ │ │ ├── vectara.md\n│ │ │ │ ├── vector.md\n│ │ │ │ └── vertexai.md\n│ │ │ ├── ingestion\n│ │ │ │ ├── index.md\n│ │ │ │ └── ray.md\n│ │ │ ├── instrumentation\n│ │ │ │ ├── event_handlers.md\n│ │ │ │ ├── event_types.md\n│ │ │ │ ├── index.md\n│ │ │ │ ├── span_handlers.md\n│ │ │ │ └── span_types.md\n│ │ │ ├── llama_dataset\n│ │ │ │ └── index.md\n│ │ │ ├── llama_deploy\n│ │ │ │ └── README.txt\n│ │ │ ├── llms\n│ │ │ │ ├── ai21.md\n│ │ │ │ ├── aibadgr.md\n│ │ │ │ ├── alephalpha.md\n│ │ │ │ ├── alibabacloud_aisearch.md\n│ │ │ │ ├── anthropic.md\n│ │ │ │ ├── anyscale.md\n│ │ │ │ ├── apertis.md\n│ │ │ │ ├── asi.md\n│ │ │ │ ├── azure_inference.md\n│ │ │ │ ├── azure_openai.md\n│ │ │ │ ├── baseten.md\n│ │ │ │ ├── bedrock.md\n│ │ │ │ ├── bedrock_converse.md\n│ │ │ │ ├── cerebras.md\n│ │ │ │ ├── clarifai.md\n│ │ │ │ ├── cleanlab.md\n│ │ │ │ ├── cloudflare_ai_gateway.md\n│ │ │ │ ├── cohere.md\n│ │ │ │ ├── cometapi.md\n│ │ │ │ ├── contextual.md\n│ │ │ │ ├── cortex.md\n│ │ │ │ ├── custom_llm.md\n│ │ │ │ ├── dashscope.md\n│ │ │ │ ├── databricks.md\n│ │ │ │ ├── deepinfra.md\n│ │ │ │ ├── deepseek.md\n│ │ │ │ ├── everlyai.md\n│ │ │ │ ├── featherlessai.md\n│ │ │ │ ├── fireworks.md\n│ │ │ │ ├── friendli.md\n│ │ │ │ ├── gaudi.md\n│ │ │ │ ├── gigachat.md\n│ │ │ │ ├── google_genai.md\n│ │ │ │ ├── groq.md\n│ │ │ │ ├── helicone.md\n│ │ │ │ ├── heroku.md\n│ │ │ │ ├── huggingface.md\n│ │ │ │ ├── huggingface_api.md\n│ │ │ │ ├── ibm.md\n│ │ │ │ ├── index.md\n│ │ │ │ ├── ipex_llm.md\n│ │ │ │ ├── keywordsai.md\n│ │ │ │ ├── konko.md\n│ │ │ │ ├── langchain.md\n│ │ │ │ ├── litellm.md\n│ │ │ │ ├── llama_api.md\n│ │ │ │ ├── llama_cpp.md\n│ │ │ │ ├── llamafile.md\n│ │ │ │ ├── lmstudio.md\n│ │ │ │ ├── localai.md\n│ │ │ │ ├── maritalk.md\n│ │ │ │ ├── meta.md\n│ │ │ │ ├── minimax.md\n│ │ │ │ ├── mistral_rs.md\n│ │ │ │ ├── mistralai.md\n│ │ │ │ ├── mlx.md\n│ │ │ │ ├── modelscope.md\n│ │ │ │ ├── modelslab.md\n│ │ │ │ ├── monsterapi.md\n│ │ │ │ ├── mymagic.md\n│ │ │ │ ├── nebius.md\n│ │ │ │ ├── netmind.md\n│ │ │ │ ├── neutrino.md\n│ │ │ │ ├── novita.md\n│ │ │ │ ├── nvidia.md\n│ │ │ │ ├── nvidia_tensorrt.md\n│ │ │ │ ├── nvidia_triton.md\n│ │ │ │ ├── oci_data_science.md\n│ │ │ │ ├── oci_genai.md\n│ │ │ │ ├── octoai.md\n│ │ │ │ ├── ollama.md\n│ │ │ │ ├── opea.md\n│ │ │ │ ├── openai.md\n│ │ │ │ ├── openai_like.md\n│ │ │ │ ├── openrouter.md\n│ │ │ │ ├── openvino.md\n│ │ │ │ ├── openvino_genai.md\n│ │ │ │ ├── optimum_intel.md\n│ │ │ │ ├── ovhcloud.md\n│ │ │ │ ├── paieas.md\n│ │ │ │ ├── palm.md\n│ │ │ │ ├── perplexity.md\n│ │ │ │ ├── pipeshift.md\n│ │ │ │ ├── portkey.md\n│ │ │ │ ├── predibase.md\n│ │ │ │ ├── premai.md\n│ │ │ │ ├── qianfan.md\n│ │ │ │ ├── reka.md\n│ │ │ │ ├── replicate.md\n│ │ │ │ ├── rungpt.md\n│ │ │ │ ├── sagemaker_endpoint.md\n│ │ │ │ ├── sambanovasystems.md\n│ │ │ │ ├── sarvam.md\n│ │ │ │ ├── servam.md\n│ │ │ │ ├── sglang.md\n│ │ │ │ ├── siliconflow.md\n│ │ │ │ ├── stepfun.md\n│ │ │ │ ├── together.md\n│ │ │ │ ├── upstage.md\n│ │ │ │ ├── vercel_ai_gateway.md\n│ │ │ │ ├── vertex.md\n│ │ │ │ ├── vllm.md\n│ │ │ │ ├── xinference.md\n│ │ │ │ ├── yi.md\n│ │ │ │ ├── you.md\n│ │ │ │ └── zhipuai.md\n│ │ │ ├── memory\n│ │ │ │ ├── bedrock_agentcore.md\n│ │ │ │ ├── chat_memory_buffer.md\n│ │ │ │ ├── index.md\n│ │ │ │ ├── mem0.md\n│ │ │ │ ├── memory.md\n│ │ │ │ ├── simple_composable_memory.md\n│ │ │ │ └── vector_memory.md\n│ │ │ ├── node_parser\n│ │ │ │ ├── alibabacloud_aisearch.md\n... (13507 more entries omitted)",
"main_features": [
"🚀 Overview",
"💡 Contributing",
"📄 Documentation",
"💻 Example Usage",
"A note on Verification of Build Assets",
"📖 Citation"
],
"metadata": {
"owner": "run-llama",
"default_branch": "main",
"topics": [
"agents",
"application",
"data",
"fine-tuning",
"framework",
"llamaindex",
"llm",
"multi-agents",
"rag",
"vector-database"
]
}
}
\ No newline at end of file
{
"repo_name": "scikit-learn",
"repo_url": "https://github.com/scikit-learn/scikit-learn",
"stars": 66666,
"primary_language": "Python",
"updated_at": "2026-07-13T06:53:03Z",
"readme_text": ".. -*- mode: rst -*-\n\n|GitHubActions| |Codecov| |CircleCI| |Nightly wheels| |Ruff| |PythonVersion| |PyPI| |DOI| |Benchmark|\n\n\n.. |GitHubActions| image:: https://github.com/scikit-learn/scikit-learn/actions/workflows/unit-tests.yml/badge.svg?\n :target: https://github.com/scikit-learn/scikit-learn/actions/workflows/unit-tests.yml?query=branch%3Amain\n\n.. |CircleCI| image:: https://circleci.com/gh/scikit-learn/scikit-learn/tree/main.svg?style=shield\n :target: https://circleci.com/gh/scikit-learn/scikit-learn\n\n.. |Codecov| image:: https://codecov.io/gh/scikit-learn/scikit-learn/branch/main/graph/badge.svg?token=Pk8G9gg3y9\n :target: https://codecov.io/gh/scikit-learn/scikit-learn\n\n.. |Nightly wheels| image:: https://github.com/scikit-learn/scikit-learn/actions/workflows/wheels.yml/badge.svg?event=schedule\n :target: https://github.com/scikit-learn/scikit-learn/actions?query=workflow%3A%22Wheel+builder%22+event%3Aschedule\n\n.. |Ruff| image:: https://img.shields.io/badge/code%20style-ruff-000000.svg?\n :target: https://github.com/astral-sh/ruff\n\n.. |PythonVersion| image:: https://img.shields.io/pypi/pyversions/scikit-learn.svg?\n :target: https://pypi.org/project/scikit-learn/\n\n.. |PyPI| image:: https://img.shields.io/pypi/v/scikit-learn\n :target: https://pypi.org/project/scikit-learn\n\n.. |DOI| image:: https://zenodo.org/badge/DOI/10.5281/zenodo.17880109.svg?\n :target: https://zenodo.org/badge/latestdoi/21369/scikit-learn/scikit-learn\n\n.. |Benchmark| image:: https://img.shields.io/badge/Benchmarked%20by-asv-blue\n :target: https://scikit-learn.org/scikit-learn-benchmarks\n\n.. |PythonMinVersion| replace:: 3.11\n.. |NumPyMinVersion| replace:: 1.24.1\n.. |SciPyMinVersion| replace:: 1.10.0\n.. |JoblibMinVersion| replace:: 1.4.0\n.. |NarwhalsMinVersion| replace:: 2.0.1\n.. |ThreadpoolctlMinVersion| replace:: 3.5.0\n.. |MatplotlibMinVersion| replace:: 3.6.1\n.. |Scikit-ImageMinVersion| replace:: 0.22.0\n.. |PandasMinVersion| replace:: 1.5.0\n.. |SeabornMinVersion| replace:: 0.13.0\n.. |PytestMinVersion| replace:: 7.1.2\n.. |PlotlyMinVersion| replace:: 5.22.0\n\n.. image:: https://raw.githubusercontent.com/scikit-learn/scikit-learn/main/doc/logos/scikit-learn-logo.png\n :target: https://scikit-learn.org/\n\n**scikit-learn** is a Python module for machine learning built on top of\nSciPy and is distributed under the 3-Clause BSD license.\n\nThe project was started in 2007 by David Cournapeau as a Google Summer\nof Code project, and since then many volunteers have contributed. See\nthe `About us <https://scikit-learn.org/dev/about.html#authors>`__ page\nfor a list of core contributors.\n\nIt is currently maintained by a team of volunteers.\n\nWebsite: https://scikit-learn.org\n\nInstallation\n------------\n\nDependencies\n~~~~~~~~~~~~\n\nscikit-learn requires:\n\n- Python (>= |PythonMinVersion|)\n- NumPy (>= |NumPyMinVersion|)\n- SciPy (>= |SciPyMinVersion|)\n- Narwhals (>= |NarwhalsMinVersion|)\n- joblib (>= |JoblibMinVersion|)\n- threadpoolctl (>= |ThreadpoolctlMinVersion|)\n\n=======\n\nScikit-learn plotting capabilities (i.e., functions start with ``plot_`` and\nclasses end with ``Display``) require Matplotlib (>= |MatplotlibMinVersion|).\nFor running the examples Matplotlib >= |MatplotlibMinVersion| is required.\nA few examples require scikit-image >= |Scikit-ImageMinVersion|, a few examples\nrequire pandas >= |PandasMinVersion|, some examples require seaborn >=\n|SeabornMinVersion| and Plotly >= |PlotlyMinVersion|.\n\nUser installation\n~~~~~~~~~~~~~~~~~\n\nIf you already have a working installation of NumPy and SciPy,\nthe easiest way to install scikit-learn is using ``pip``::\n\n pip install -U scikit-learn\n\nor ``conda``::\n\n conda install -c conda-forge scikit-learn\n\nThe documentation includes more detailed `installation instructions <https://scikit-learn.org/stable/install.html>`_.\n\n\nChangelog\n---------\n\nSee the `changelog <https://scikit-learn.org/dev/whats_new.html>`__\nfor a history of notable changes to scikit-learn.\n\nDevelopment\n-----------\n\nWe welcome new contributors of all experience levels. The scikit-learn\ncommunity goals are to be helpful, welcoming, and effective. The\n`Development Guide <https://scikit-learn.org/stable/developers/index.html>`_\nhas detailed information about contributing code, documentation, tests, and\nmore. We've included some basic information in this README.\n\nImportant links\n~~~~~~~~~~~~~~~\n\n- Official source code repo: https://github.com/scikit-learn/scikit-learn\n- Download releases: https://pypi.org/project/scikit-learn/\n- Issue tracker: https://github.com/scikit-learn/scikit-learn/issues\n\nSource code\n~~~~~~~~~~~\n\nYou can check the latest sources with the command::\n\n git clone https://github.com/scikit-learn/scikit-learn.git\n\nContributing\n~~~~~~~~~~~~\n\nTo learn more about making a contribution to scikit-learn, please see our\n`Contributing guide\n<https://scikit-learn.org/dev/developers/contributing.html>`_.\n\nTesting\n~~~~~~~\n\nAfter installation, you can launch the test suite from outside the source\ndirectory (you will need to have ``pytest`` >= |PytestMinVersion| installed)::\n\n pytest sklearn\n\nSee the web page https://scikit-learn.org/dev/developers/contributing.html#testing-and-improving-test-coverage\nfor more information.\n\n Random number generation can be controlled during testing by setting\n the ``SKLEARN_SEED`` environment variable.\n\nSubmitting a Pull Request\n~~~~~~~~~~~~~~~~~~~~~~~~~\n\nBefore opening a Pull Request, have a look at the\nfull Contributing page to make sure your code complies\nwith our guidelines: https://scikit-learn.org/stable/developers/index.html\n\nProject History\n---------------\n\nThe project was started in 2007 by David Cournapeau as a Google Summer\nof Code project, and since then many volunteers have contributed. See\nthe `About us <https://scikit-learn.org/dev/about.html#authors>`__ page\nfor a list of core contributors.\n\nThe project is currently maintained by a team of volunteers.\n\n**Note**: `scikit-learn` was previously referred to as `scikits.learn`.\n\nHelp and Support\n----------------\n\nDocumentation\n~~~~~~~~~~~~~\n\n- HTML documentation (stable release): https://scikit-learn.org\n- HTML documentation (development version): https://scikit-learn.org/dev/\n- FAQ: https://scikit-learn.org/stable/faq.html\n\nCommunication\n~~~~~~~~~~~~~\n\nMain Channels\n^^^^^^^^^^^^^\n\n- **Website**: https://scikit-learn.org\n- **Blog**: https://blog.scikit-learn.org\n- **Mailing list**: https://mail.python.org/mailman/listinfo/scikit-learn\n\nDeveloper & Support\n^^^^^^^^^^^^^^^^^^^^^^\n\n- **GitHub Discussions**: https://github.com/scikit-learn/scikit-learn/discussions\n- **Stack Overflow**: https://stackoverflow.com/questions/tagged/scikit-learn\n- **Discord**: https://discord.gg/h9qyrK8Jc8\n\nSocial Media Platforms\n^^^^^^^^^^^^^^^^^^^^^^\n\n- **LinkedIn**: https://www.linkedin.com/company/scikit-learn\n- **YouTube**: https://www.youtube.com/channel/UCJosFjYm0ZYVUARxuOZqnnw/playlists\n- **Facebook**: https://www.facebook.com/scikitlearnofficial/\n- **Instagram**: https://www.instagram.com/scikitlearnofficial/\n- **TikTok**: https://www.tiktok.com/@scikit.learn\n- **Bluesky**: https://bsky.app/profile/scikit-learn.org\n- **Mastodon**: https://mastodon.social/@sklearn@fosstodon.org\n\nResources\n^^^^^^^^^\n\n- **Calendar**: https://blog.scikit-learn.org/calendar/\n- **Logos & Branding**: https://github.com/scikit-learn/scikit-learn/tree/main/doc/logos\n\nCitation\n~~~~~~~~\n\nIf you use scikit-learn in a scientific publication, we would appreciate citations: https://scikit-learn.org/stable/about.html#citing-scikit-learn",
"directory_tree": "├── .binder\n│ ├── postBuild\n│ ├── requirements.txt\n│ └── runtime.txt\n├── .circleci\n│ └── config.yml\n├── .devcontainer\n│ ├── devcontainer.json\n│ └── setup.sh\n├── .github\n│ ├── ISSUE_TEMPLATE\n│ │ ├── bug_report.yml\n│ │ ├── config.yml\n│ │ ├── doc_improvement.yml\n│ │ └── feature_request.yml\n│ ├── scripts\n│ │ ├── add_or_remove_no_pr_warning.py\n│ │ └── label_title_regex.py\n│ ├── workflows\n│ │ ├── artifact-redirector.yml\n│ │ ├── autoclose-comment.yml\n│ │ ├── autoclose-schedule.yml\n│ │ ├── bot-lint-comment.yml\n│ │ ├── check-changelog.yml\n│ │ ├── check-sdist.yml\n│ │ ├── codeql.yml\n│ │ ├── codespell.yml\n│ │ ├── cuda-ci.yml\n│ │ ├── cuda-label-remover.yml\n│ │ ├── emscripten.yml\n│ │ ├── label-blank-issue.yml\n│ │ ├── labeler-module.yml\n│ │ ├── labeler-title-regex.yml\n│ │ ├── lint.yml\n│ │ ├── needs-decision.yml\n│ │ ├── not-ready-for-pr-warning.yml\n│ │ ├── publish_pypi.yml\n│ │ ├── unit-tests.yml\n│ │ ├── update-lock-files.yml\n│ │ ├── update_tracking_issue.yml\n│ │ ├── welcome-first-time-contributor.yml\n│ │ └── wheels.yml\n│ ├── dependabot.yml\n│ ├── FUNDING.yml\n│ ├── labeler-file-extensions.yml\n│ ├── labeler-module.yml\n│ └── PULL_REQUEST_TEMPLATE.md\n├── .spin\n│ └── cmds.py\n├── asv_benchmarks\n│ ├── benchmarks\n│ │ ├── __init__.py\n│ │ ├── cluster.py\n│ │ ├── common.py\n│ │ ├── config.json\n│ │ ├── datasets.py\n│ │ ├── decomposition.py\n│ │ ├── ensemble.py\n│ │ ├── linear_model.py\n│ │ ├── manifold.py\n│ │ ├── metrics.py\n│ │ ├── model_selection.py\n│ │ ├── neighbors.py\n│ │ ├── svm.py\n│ │ └── utils.py\n│ ├── .gitignore\n│ └── asv.conf.json\n├── benchmarks\n│ ├── .gitignore\n│ ├── bench_20newsgroups.py\n│ ├── bench_covertype.py\n│ ├── bench_feature_expansions.py\n│ ├── bench_glm.py\n│ ├── bench_glmnet.py\n│ ├── bench_hist_gradient_boosting.py\n│ ├── bench_hist_gradient_boosting_adult.py\n│ ├── bench_hist_gradient_boosting_categorical_only.py\n│ ├── bench_hist_gradient_boosting_higgsboson.py\n│ ├── bench_hist_gradient_boosting_threading.py\n│ ├── bench_isolation_forest.py\n│ ├── bench_isolation_forest_predict.py\n│ ├── bench_isotonic.py\n│ ├── bench_kernel_pca_solvers_time_vs_n_components.py\n│ ├── bench_kernel_pca_solvers_time_vs_n_samples.py\n│ ├── bench_lasso.py\n│ ├── bench_lof.py\n│ ├── bench_mnist.py\n│ ├── bench_online_ocsvm.py\n│ ├── bench_pca_solvers.py\n│ ├── bench_plot_fastkmeans.py\n│ ├── bench_plot_hierarchical.py\n│ ├── bench_plot_incremental_pca.py\n│ ├── bench_plot_lasso_path.py\n│ ├── bench_plot_neighbors.py\n│ ├── bench_plot_nmf.py\n│ ├── bench_plot_omp_lars.py\n│ ├── bench_plot_parallel_pairwise.py\n│ ├── bench_plot_polynomial_kernel_approximation.py\n│ ├── bench_plot_randomized_svd.py\n│ ├── bench_plot_svd.py\n│ ├── bench_plot_ward.py\n│ ├── bench_random_projections.py\n│ ├── bench_rcv1_logreg_convergence.py\n│ ├── bench_saga.py\n│ ├── bench_sample_without_replacement.py\n│ ├── bench_sgd_regression.py\n│ ├── bench_sparsify.py\n│ ├── bench_text_vectorizers.py\n│ ├── bench_tree.py\n│ ├── bench_tsne_mnist.py\n│ └── plot_tsne_mnist.py\n├── build_tools\n│ ├── circle\n│ │ ├── build_doc.sh\n│ │ ├── checkout_merge_commit.sh\n│ │ ├── doc_environment.yml\n│ │ ├── doc_linux-64_conda.lock\n│ │ ├── doc_min_dependencies_environment.yml\n│ │ ├── doc_min_dependencies_linux-64_conda.lock\n│ │ ├── download_documentation.sh\n│ │ ├── list_versions.py\n│ │ └── push_doc.sh\n│ ├── github\n│ │ ├── autoclose_prs.py\n│ │ ├── build_minimal_windows_image.sh\n│ │ ├── build_source.sh\n│ │ ├── check_build_trigger.sh\n│ │ ├── check_wheels.py\n│ │ ├── combine_coverage_reports.sh\n│ │ ├── create_gpu_environment.sh\n│ │ ├── debian_32bit_lock.txt\n│ │ ├── debian_32bit_requirements.txt\n│ │ ├── install.sh\n│ │ ├── lint_lock.txt\n│ │ ├── lint_requirements.txt\n│ │ ├── pylatest_conda_forge_cuda_array-api_linux-64_conda.lock\n│ │ ├── pylatest_conda_forge_cuda_array-api_linux-64_environment.yml\n│ │ ├── pylatest_conda_forge_cuda_array-api_linux-64_virtual_package_spec.yml\n│ │ ├── pylatest_conda_forge_mkl_linux-64_conda.lock\n│ │ ├── pylatest_conda_forge_mkl_linux-64_environment.yml\n│ │ ├── pylatest_conda_forge_mkl_no_openmp_environment.yml\n│ │ ├── pylatest_conda_forge_mkl_no_openmp_osx-64_conda.lock\n│ │ ├── pylatest_conda_forge_osx-arm64_conda.lock\n│ │ ├── pylatest_conda_forge_osx-arm64_environment.yml\n│ │ ├── pylatest_free_threaded_environment.yml\n│ │ ├── pylatest_free_threaded_linux-64_conda.lock\n│ │ ├── pylatest_pip_openblas_pandas_environment.yml\n│ │ ├── pylatest_pip_openblas_pandas_linux-64_conda.lock\n│ │ ├── pylatest_pip_scipy_dev_environment.yml\n│ │ ├── pylatest_pip_scipy_dev_linux-64_conda.lock\n│ │ ├── pymin_conda_forge_arm_environment.yml\n│ │ ├── pymin_conda_forge_arm_linux-aarch64_conda.lock\n│ │ ├── pymin_conda_forge_openblas_environment.yml\n│ │ ├── pymin_conda_forge_openblas_min_dependencies_environment.yml\n│ │ ├── pymin_conda_forge_openblas_min_dependencies_linux-64_conda.lock\n│ │ ├── pymin_conda_forge_openblas_ubuntu_2204_environment.yml\n│ │ ├── pymin_conda_forge_openblas_ubuntu_2204_linux-64_conda.lock\n│ │ ├── pymin_conda_forge_openblas_win-64_conda.lock\n│ │ ├── repair_windows_wheels.sh\n│ │ ├── test_docs.sh\n│ │ ├── test_pytest_soft_dependency.sh\n│ │ ├── test_script.sh\n│ │ ├── test_source.sh\n│ │ ├── test_windows_wheels.sh\n│ │ ├── ubuntu_atlas_lock.txt\n│ │ ├── ubuntu_atlas_requirements.txt\n│ │ ├── upload_anaconda.sh\n│ │ └── vendor.py\n│ ├── wheels\n│ │ ├── build_wheels.sh\n│ │ ├── check_license.py\n│ │ ├── cibw_before_build.sh\n│ │ ├── LICENSE_linux.txt\n│ │ ├── LICENSE_macos.txt\n│ │ ├── LICENSE_windows.txt\n│ │ └── test_wheels.sh\n│ ├── check-meson-openmp-dependencies.py\n│ ├── codespell_ignore_words.txt\n│ ├── generate_authors_table.py\n│ ├── get_comment.py\n│ ├── linting.sh\n│ ├── Makefile\n│ ├── shared.sh\n│ └── update_environments_and_lock_files.py\n├── doc\n│ ├── api\n│ │ ├── deprecated.rst.template\n│ │ ├── index.rst.template\n│ │ └── module.rst.template\n│ ├── binder\n│ │ └── requirements.txt\n│ ├── computing\n│ │ ├── computational_performance.rst\n│ │ ├── parallelism.rst\n│ │ └── scaling_strategies.rst\n│ ├── css\n│ │ └── styles\n│ │ ├── api-search.css\n│ │ ├── api.css\n│ │ ├── colors.css\n│ │ ├── custom.css\n│ │ └── index.css\n│ ├── datasets\n│ │ ├── loading_other_datasets.rst\n│ │ ├── real_world.rst\n│ │ ├── sample_generators.rst\n│ │ └── toy_dataset.rst\n│ ├── developers\n│ │ ├── bug_triaging.rst\n│ │ ├── callback_support.rst\n│ │ ├── callbacks.rst\n│ │ ├── contributing.rst\n│ │ ├── cython.rst\n│ │ ├── develop.rst\n│ │ ├── developing_callbacks.rst\n│ │ ├── development_setup.rst\n│ │ ├── index.rst\n│ │ ├── maintainer.rst.template\n│ │ ├── minimal_reproducer.rst\n│ │ ├── misc_info.rst\n│ │ ├── performance.rst\n│ │ ├── plotting.rst\n│ │ ├── tips.rst\n│ │ └── utilities.rst\n│ ├── images\n│ │ ├── axa-small.png\n│ │ ├── axa.png\n│ │ ├── bcg.png\n│ │ ├── beta_divergence.png\n│ │ ├── bnp-paribas-small.png\n│ │ ├── bnp-paribas.png\n│ │ ├── bnp-small.png\n│ │ ├── bnp.png\n│ │ ├── cds-logo.png\n│ │ ├── chanel-small.png\n│ │ ├── chanel.png\n│ │ ├── columbia-small.png\n│ │ ├── columbia.png\n│ │ ├── czi-small.png\n│ │ ├── czi.png\n│ │ ├── dataiku-small.png\n│ │ ├── dataiku.png\n│ │ ├── digicosme.png\n│ │ ├── dysco.png\n│ │ ├── fnrs-logo-small.png\n│ │ ├── fujitsu.png\n│ │ ├── generated-doc-ci.png\n│ │ ├── google-small.png\n│ │ ├── grid_search_cross_validation.png\n│ │ ├── grid_search_workflow.png\n│ │ ├── huggingface_logo-noborder.png\n│ │ ├── inria-logo.jpg\n│ │ ├── inria-small.png\n│ │ ├── intel-small.png\n│ │ ├── intel.png\n│ │ ├── iris.pdf\n│ │ ├── iris.svg\n│ │ ├── last_digit.png\n│ │ ├── lda_model_graph.png\n│ │ ├── logo_APHP.png\n│ │ ├── logo_APHP_text.png\n│ │ ├── michelin-small.png\n│ │ ├── michelin.png\n│ │ ├── microsoft-small.png\n│ │ ├── microsoft.png\n│ │ ├── ml_map.README.rst\n│ │ ├── ml_map.svg\n│ │ ├── multi_org_chart.png\n│ │ ├── multilayerperceptron_network.png\n│ │ ├── nasa-small.png\n│ │ ├── nasa.png\n│ │ ├── no_image.png\n│ │ ├── nvidia-small.png\n│ │ ├── nvidia.png\n│ │ ├── nyu_short_color.png\n│ │ ├── permuted_non_predictive_feature.png\n│ │ ├── permuted_predictive_feature.png\n│ │ ├── plot_digits_classification.png\n│ │ ├── plot_face_recognition_1.png\n│ │ ├── plot_face_recognition_2.png\n│ │ ├── png-logo-inria-la-fondation.png\n│ │ ├── probabl.png\n│ │ ├── quansight-labs-small.png\n│ │ ├── quansight-labs.png\n│ │ ├── rbm_graph.png\n│ │ ├── scikit-learn-logo-notext.png\n│ │ ├── scikit-learn-logo-small.png\n│ │ ├── sloan_banner.png\n│ │ ├── sloan_logo-small.png\n│ │ ├── sydney-primary.jpeg\n│ │ ├── sydney-stacked-small.png\n│ │ ├── target_encoder_cross_validation.svg\n│ │ ├── telecom-small.png\n│ │ ├── telecom.png\n│ │ ├── Tidelift-logo-on-light.svg\n│ │ ├── visual-studio-build-tools-selection.png\n│ │ ├── wellcome-trust-small.png\n│ │ └── wellcome-trust.png\n│ ├── js\n│ │ └── scripts\n... (1731 more entries omitted)",
"main_features": [
"Data analysis",
"Data science",
"Machine learning",
"Python",
"Statistics"
],
"metadata": {
"owner": "scikit-learn",
"default_branch": "main",
"topics": [
"data-analysis",
"data-science",
"machine-learning",
"python",
"statistics"
]
}
}
\ No newline at end of file
{
"repo_name": "streamlit",
"repo_url": "https://github.com/streamlit/streamlit",
"stars": 45220,
"primary_language": "Python",
"updated_at": "2026-07-13T07:43:05Z",
"readme_text": "<br>\n\n<img src=\"https://user-images.githubusercontent.com/7164864/217935870-c0bc60a3-6fc0-4047-b011-7b4c59488c91.png\" alt=\"Streamlit logo\" style=\"margin-top:50px\"></img>\n\n# Welcome to Streamlit 👋\n\n**A faster way to build and share data apps.**\n\n## What is Streamlit?\n\nStreamlit lets you transform Python scripts into interactive web apps in minutes, instead of weeks. Build dashboards, generate reports, or create chat apps. Once you’ve created an app, you can use our [Community Cloud platform](https://streamlit.io/cloud) to deploy, manage, and share your app.\n\n### Why choose Streamlit?\n\n- **Simple and Pythonic:** Write beautiful, easy-to-read code.\n- **Fast, interactive prototyping:** Let others interact with your data and provide feedback quickly.\n- **Live editing:** See your app update instantly as you edit your script.\n- **Open-source and free:** Join a vibrant community and contribute to Streamlit's future.\n\n## Installation\n\nOpen a terminal and run:\n\n```bash\n$ pip install streamlit\n$ streamlit hello\n```\n\nIf this opens our sweet _Streamlit Hello_ app in your browser, you're all set! If not, head over to [our docs](https://docs.streamlit.io/get-started) for specific installs.\n\nThe app features a bunch of examples of what you can do with Streamlit. Jump to the [quickstart](#quickstart) section to understand how that all works.\n\n<img src=\"https://user-images.githubusercontent.com/7164864/217936487-1017784e-68ec-4e0d-a7f6-6b97525ddf88.gif\" alt=\"Streamlit Hello\" width=500 href=\"none\"></img>\n\n## Quickstart\n\n### A little example\n\nCreate a new file named `streamlit_app.py` in your project directory with the following code:\n```python\nimport streamlit as st\nx = st.slider(\"Select a value\")\nst.write(x, \"squared is\", x * x)\n```\n\nNow run it to open the app!\n```\n$ streamlit run streamlit_app.py\n```\n\n<img src=\"https://user-images.githubusercontent.com/7164864/215172915-cf087c56-e7ae-449a-83a4-b5fa0328d954.gif\" width=300 alt=\"Little example\"></img>\n\n### Give me more!\n\nStreamlit comes in with [a ton of additional powerful elements](https://docs.streamlit.io/develop/api-reference) to spice up your data apps and delight your viewers. Some examples:\n\n<table border=\"0\">\n <tr>\n <td>\n <a target=\"_blank\" href=\"https://docs.streamlit.io/develop/api-reference/widgets\">\n <img src=\"https://user-images.githubusercontent.com/7164864/217936099-12c16f8c-7fe4-44b1-889a-1ac9ee6a1b44.png\" style=\"max-height:150px; width:auto; display:block;\">\n </a>\n </td>\n <td>\n <a target=\"_blank\" href=\"https://docs.streamlit.io/develop/api-reference/data/st.dataframe\">\n <img src=\"https://user-images.githubusercontent.com/7164864/215110064-5eb4e294-8f30-4933-9563-0275230e52b5.gif\" style=\"max-height:150px; width:auto; display:block;\">\n </a>\n </td>\n <td>\n <a target=\"_blank\" href=\"https://docs.streamlit.io/develop/api-reference/charts\">\n <img src=\"https://user-images.githubusercontent.com/7164864/215174472-bca8a0d7-cf4b-4268-9c3b-8c03dad50bcd.gif\" style=\"max-height:150px; width:auto; display:block;\">\n </a>\n </td>\n <td>\n <a target=\"_blank\" href=\"https://docs.streamlit.io/develop/api-reference/layout\">\n <img src=\"https://user-images.githubusercontent.com/7164864/217936149-a35c35be-0d96-4c63-8c6a-1c4b52aa8f60.png\" style=\"max-height:150px; width:auto; display:block;\">\n </a>\n </td>\n <td>\n <a target=\"_blank\" href=\"https://docs.streamlit.io/develop/concepts/multipage-apps\">\n <img src=\"https://user-images.githubusercontent.com/7164864/215173883-eae0de69-7c1d-4d78-97d0-3bc1ab865e5b.gif\" style=\"max-height:150px; width:auto; display:block;\">\n </a>\n </td>\n <td>\n <a target=\"_blank\" href=\"https://streamlit.io/gallery\">\n <img src=\"https://user-images.githubusercontent.com/7164864/215109229-6ae9111f-e5c1-4f0b-b3a2-87a79268ccc9.gif\" style=\"max-height:150px; width:auto; display:block;\">\n </a>\n </td>\n </tr>\n <tr>\n <td>Input widgets</td>\n <td>Dataframes</td>\n <td>Charts</td>\n <td>Layout</td>\n <td>Multi-page apps</td>\n <td>Fun</td>\n </tr>\n</table>\n\n\nOur vibrant creators community also extends Streamlit capabilities using  🧩 [Streamlit Components](https://streamlit.io/components).\n\n## Get inspired\n\nThere's so much you can build with Streamlit:\n- 🤖  [LLMs & chatbot apps](https://streamlit.io/gallery?category=llms)\n- 🧬  [Science & technology apps](https://streamlit.io/gallery?category=science-technology)\n- 💬  [NLP & language apps](https://streamlit.io/gallery?category=nlp-language)\n- 🏦  [Finance & business apps](https://streamlit.io/gallery?category=finance-business)\n- 🗺  [Geography & society apps](https://streamlit.io/gallery?category=geography-society)\n- and more!\n\n**Check out [our gallery!](https://streamlit.io/gallery)** 🎈\n\n## Community Cloud\n\nDeploy, manage and share your apps for free using our [Community Cloud](https://streamlit.io/cloud)! Sign-up [here](https://share.streamlit.io/signup). <br><br>\n<img src=\"https://user-images.githubusercontent.com/7164864/214965336-64500db3-0d79-4a20-8052-2dda883902d2.gif\" width=\"400\"></img>\n\n## Resources\n\n- Explore our [docs](https://docs.streamlit.io) to learn how Streamlit works.\n- Ask questions and get help in our [community forum](https://discuss.streamlit.io).\n- Read our [blog](https://blog.streamlit.io) for tips from developers and creators.\n- Extend Streamlit's capabilities by installing or creating your own [Streamlit Components](https://streamlit.io/components).\n- Help others find and play with your app by using the Streamlit GitHub badge in your repository:\n```markdown\n[![Streamlit App](https://static.streamlit.io/badges/streamlit_badge_black_white.svg)](URL_TO_YOUR_APP)\n```\n[![Streamlit App](https://static.streamlit.io/badges/streamlit_badge_black_white.svg)](https://share.streamlit.io/streamlit/roadmap)\n\n## Contribute\n\n🎉 Thanks for your interest in helping improve Streamlit! 🎉\n\nBefore contributing, please read our guidelines here: https://github.com/streamlit/streamlit/blob/develop/CONTRIBUTING.md\n\n## License\n\nStreamlit is completely free and open-source and licensed under the [Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0) license.",
"directory_tree": "├── .claude\n│ ├── agents\n│ │ ├── AGENTS.md\n│ │ ├── CLAUDE.md\n│ │ ├── fixing-pr.md\n│ │ ├── qa-testing-feature.md\n│ │ ├── reviewing-local-changes.md\n│ │ └── simplifying-local-changes.md\n│ ├── commands\n│ │ ├── fixing-pr.md\n│ │ ├── qa-testing-feature.md\n│ │ ├── reviewing-local-changes.md\n│ │ └── simplifying-local-changes.md\n│ ├── hooks\n│ │ ├── post_edit_autofix.sh\n│ │ ├── pre_bash_redirect.py\n│ │ └── stop_check.sh\n│ ├── skills\n│ │ ├── addressing-pr-review-comments\n│ │ │ └── SKILL.md\n│ │ ├── assessing-external-test-risk\n│ │ │ └── SKILL.md\n│ │ ├── checking-changes\n│ │ │ └── SKILL.md\n│ │ ├── creating-pull-requests\n│ │ │ └── SKILL.md\n│ │ ├── debugging-streamlit\n│ │ │ └── SKILL.md\n│ │ ├── discovering-make-commands\n│ │ │ └── SKILL.md\n│ │ ├── finalizing-pr\n│ │ │ └── SKILL.md\n│ │ ├── fixing-flaky-e2e-tests\n│ │ │ └── SKILL.md\n│ │ ├── fixing-streamlit-ci\n│ │ │ └── SKILL.md\n│ │ ├── generating-changelog\n│ │ │ └── SKILL.md\n│ │ ├── implementing-feature\n│ │ │ └── SKILL.md\n│ │ ├── improving-frontend-coverage\n│ │ │ └── SKILL.md\n│ │ ├── improving-python-coverage\n│ │ │ └── SKILL.md\n│ │ ├── sharing-pr-agent-artifacts\n│ │ │ └── SKILL.md\n│ │ ├── understanding-streamlit-architecture\n│ │ │ ├── references\n│ │ │ │ ├── backend.md\n│ │ │ │ ├── communication.md\n│ │ │ │ ├── element-identity.md\n│ │ │ │ ├── frontend.md\n│ │ │ │ └── layout.md\n│ │ │ └── SKILL.md\n│ │ ├── updating-internal-docs\n│ │ │ └── SKILL.md\n│ │ ├── writing-spec\n│ │ │ └── SKILL.md\n│ │ ├── AGENTS.md\n│ │ └── CLAUDE.md\n│ ├── .gitignore\n│ └── settings.json\n├── .codex\n│ ├── agents\n│ │ ├── fixing-pr.toml\n│ │ ├── qa-testing-feature.toml\n│ │ ├── reviewing-local-changes.toml\n│ │ └── simplifying-local-changes.toml\n│ ├── .gitignore\n│ ├── config.toml\n│ └── skills\n├── .cursor\n│ ├── rules\n│ │ ├── agents.mdc\n│ │ ├── e2e_playwright.mdc\n│ │ ├── overview.mdc\n│ │ ├── protobuf.mdc\n│ │ ├── python.mdc\n│ │ ├── python_lib.mdc\n│ │ ├── python_tests.mdc\n│ │ ├── scripts.mdc\n│ │ ├── skills.mdc\n│ │ ├── specs.mdc\n│ │ ├── typescript.mdc\n│ │ └── workflows.mdc\n│ ├── .gitignore\n│ ├── hooks.json\n│ └── worktrees.json\n├── .devcontainer\n│ ├── devcontainer.json\n│ └── Dockerfile\n├── .github\n│ ├── actions\n│ │ ├── apt_mirror_fix\n│ │ │ ├── action.yml\n│ │ │ └── apt_mirror_fix.sh\n│ │ ├── build_info\n│ │ │ └── action.yml\n│ │ ├── make_init\n│ │ │ └── action.yml\n│ │ ├── playwright_install\n│ │ │ └── action.yml\n│ │ └── preview_branch\n│ │ └── action.yml\n│ ├── instructions\n│ │ ├── agents.instructions.md\n│ │ ├── e2e_playwright.instructions.md\n│ │ ├── protobuf.instructions.md\n│ │ ├── python.instructions.md\n│ │ ├── python_lib.instructions.md\n│ │ ├── python_tests.instructions.md\n│ │ ├── scripts.instructions.md\n│ │ ├── skills.instructions.md\n│ │ ├── specs.instructions.md\n│ │ ├── typescript.instructions.md\n│ │ └── workflows.instructions.md\n│ ├── ISSUE_TEMPLATE\n│ │ ├── bug_report.yml\n│ │ ├── config.yml\n│ │ ├── feature_request.yml\n│ │ └── thank_streamlit_team.yml\n│ ├── workflows\n│ │ ├── AGENTS.md\n│ │ ├── ai-fix-flaky-e2e-tests.yml\n│ │ ├── ai-issue-triage.yml\n│ │ ├── ai-pr-review.yml\n│ │ ├── ai-qa-testing.yml\n│ │ ├── ai-test-coverage.yml\n│ │ ├── ai-update-docs.yml\n│ │ ├── autofix.yml\n│ │ ├── bump-component-v2-lib.yml\n│ │ ├── cherry-pick-to-release-branch.yml\n│ │ ├── CLAUDE.md\n│ │ ├── cli-regression.yml\n│ │ ├── codeql-analysis.yml\n│ │ ├── community-voting.yml\n│ │ ├── component-template-e2e-tests.yml\n│ │ ├── copilot-setup-steps.yml\n│ │ ├── enforce-pre-commit.yml\n│ │ ├── ensure-relative-imports.yml\n│ │ ├── flaky-js-test-verification.yml\n│ │ ├── flaky-test-verification.yml\n│ │ ├── fork-pr-welcome.yml\n│ │ ├── js-tests.yml\n│ │ ├── js-unit-tests.yml\n│ │ ├── load-testing.yml\n│ │ ├── nightly.yml\n│ │ ├── patch-release-branch-creation.yml\n│ │ ├── performance.yml\n│ │ ├── playwright-changed-files.yml\n│ │ ├── playwright-custom-components.yml\n│ │ ├── playwright.yml\n│ │ ├── pr-preview.yml\n│ │ ├── publish-component-v2-lib.yml\n│ │ ├── python-bare-executions.yml\n│ │ ├── python-tests.yml\n│ │ ├── release-branch-creation.yml\n│ │ ├── release-tag-and-pr-creation.yml\n│ │ ├── release.yml\n│ │ ├── require-labels.yml\n│ │ ├── semgrep.yml\n│ │ ├── snapshot-autofix.yml\n│ │ ├── snapshot-hygiene.yml\n│ │ ├── spec-validation.yml\n│ │ ├── stale-prs.yml\n│ │ ├── static-deploy.yml\n│ │ ├── update-browserslist-db.yml\n│ │ └── update-emojis-material-icons.yml\n│ ├── .gitignore\n│ ├── CODEOWNERS\n│ ├── codeql-config.yml\n│ ├── copilot-instructions.md\n│ ├── dependabot.yml\n│ ├── pull_request_template.md\n│ ├── release.yml\n│ └── repo_meta.yaml\n├── .vscode\n│ ├── extensions.json\n│ ├── launch.json\n│ └── settings.json\n├── e2e_playwright\n│ ├── .streamlit\n│ │ └── secrets.toml\n│ ├── __snapshots__\n│ │ └── linux\n│ │ ├── appnode_hierarchy_test\n│ │ │ ├── appnode_hierarchy-long_compute[chromium].png\n│ │ │ ├── appnode_hierarchy-long_compute[firefox].png\n│ │ │ └── appnode_hierarchy-long_compute[webkit].png\n│ │ ├── compilation_error_dialog_test\n│ │ │ ├── compilation_error-dialog[chromium].png\n│ │ │ ├── compilation_error-dialog[firefox].png\n│ │ │ └── compilation_error-dialog[webkit].png\n│ │ ├── custom_background_colors_test\n│ │ │ ├── custom_background_colors_app[chromium].png\n│ │ │ ├── custom_background_colors_app[firefox].png\n│ │ │ └── custom_background_colors_app[webkit].png\n│ │ ├── custom_dark_sidebar_theme_test\n│ │ │ ├── custom_dark_sidebar_theme[chromium].png\n│ │ │ ├── custom_dark_sidebar_theme[firefox].png\n│ │ │ ├── custom_dark_sidebar_theme[webkit].png\n│ │ │ ├── custom_dark_sidebar_theme_auto[chromium].png\n│ │ │ ├── custom_dark_sidebar_theme_auto[firefox].png\n│ │ │ ├── custom_dark_sidebar_theme_auto[webkit].png\n│ │ │ ├── custom_light_sidebar_theme_no_light_configs[chromium].png\n│ │ │ ├── custom_light_sidebar_theme_no_light_configs[firefox].png\n│ │ │ └── custom_light_sidebar_theme_no_light_configs[webkit].png\n│ │ ├── custom_dark_theme_test\n│ │ │ ├── custom_dark_themed_app[chromium].png\n│ │ │ ├── custom_dark_themed_app[firefox].png\n│ │ │ ├── custom_dark_themed_app[webkit].png\n│ │ │ ├── custom_light_theme_no_light_configs[chromium].png\n│ │ │ ├── custom_light_theme_no_light_configs[firefox].png\n│ │ │ ├── custom_light_theme_no_light_configs[webkit].png\n│ │ │ ├── custom_theme_auto_dark[chromium].png\n│ │ │ ├── custom_theme_auto_dark[firefox].png\n│ │ │ └── custom_theme_auto_dark[webkit].png\n│ │ ├── custom_light_sidebar_theme_test\n│ │ │ ├── custom_dark_sidebar_theme_no_dark_configs[chromium].png\n│ │ │ ├── custom_dark_sidebar_theme_no_dark_configs[firefox].png\n│ │ │ ├── custom_dark_sidebar_theme_no_dark_configs[webkit].png\n│ │ │ ├── custom_light_sidebar_theme[chromium].png\n│ │ │ ├── custom_light_sidebar_theme[firefox].png\n│ │ │ ├── custom_light_sidebar_theme[webkit].png\n│ │ │ ├── custom_light_sidebar_theme_auto[chromium].png\n│ │ │ ├── custom_light_sidebar_theme_auto[firefox].png\n│ │ │ └── custom_light_sidebar_theme_auto[webkit].png\n│ │ ├── custom_light_theme_test\n│ │ │ ├── custom_dark_theme_with_dark_configs[chromium].png\n│ │ │ ├── custom_dark_theme_with_dark_configs[firefox].png\n│ │ │ ├── custom_dark_theme_with_dark_configs[webkit].png\n│ │ │ ├── custom_light_themed_app[chromium].png\n│ │ │ ├── custom_light_themed_app[firefox].png\n│ │ │ ├── custom_light_themed_app[webkit].png\n│ │ │ ├── custom_theme_auto_light[chromium].png\n│ │ │ ├── custom_theme_auto_light[firefox].png\n│ │ │ ├── custom_theme_auto_light[webkit].png\n│ │ │ ├── persisted_on_reload_after[chromium].png\n│ │ │ ├── persisted_on_reload_after[firefox].png\n│ │ │ ├── persisted_on_reload_after[webkit].png\n│ │ │ ├── persisted_on_reload_before[chromium].png\n│ │ │ ├── persisted_on_reload_before[firefox].png\n│ │ │ └── persisted_on_reload_before[webkit].png\n│ │ ├── custom_main_colors_test\n│ │ │ ├── custom_main_colors_app[chromium].png\n│ │ │ ├── custom_main_colors_app[firefox].png\n│ │ │ └── custom_main_colors_app[webkit].png\n│ │ ├── custom_text_colors_test\n│ │ │ ├── custom_text_colors_app[chromium].png\n│ │ │ ├── custom_text_colors_app[firefox].png\n│ │ │ └── custom_text_colors_app[webkit].png\n│ │ ├── custom_theme_fonts_test\n│ │ │ ├── custom_fonts_app[chromium].png\n│ │ │ ├── custom_fonts_app[firefox].png\n│ │ │ ├── custom_fonts_app[webkit].png\n│ │ │ ├── custom_fonts_main_menu[chromium].png\n│ │ │ ├── custom_fonts_main_menu[firefox].png\n│ │ │ └── custom_fonts_main_menu[webkit].png\n│ │ ├── custom_theme_test\n│ │ │ ├── custom_themed_app[chromium].png\n│ │ │ ├── custom_themed_app[firefox].png\n│ │ │ └── custom_themed_app[webkit].png\n│ │ ├── custom_url_base_test\n│ │ │ ├── custom_theme_with_url_base[chromium].png\n│ │ │ ├── custom_theme_with_url_base[firefox].png\n│ │ │ └── custom_theme_with_url_base[webkit].png\n│ │ ├── deploy_dialog_test\n│ │ │ ├── deploy_dialog[dark_theme-chromium].png\n│ │ │ ├── deploy_dialog[dark_theme-firefox].png\n│ │ │ ├── deploy_dialog[dark_theme-webkit].png\n│ │ │ ├── deploy_dialog[light_theme-chromium].png\n│ │ │ ├── deploy_dialog[light_theme-firefox].png\n│ │ │ └── deploy_dialog[light_theme-webkit].png\n│ │ ├── font_style_test\n│ │ │ ├── font_style-font_styles[chromium].png\n│ │ │ ├── font_style-font_styles[firefox].png\n│ │ │ └── font_style-font_styles[webkit].png\n│ │ ├── font_unicode_range_test\n│ │ │ ├── font_unicode_range-font_unicode_ranges[chromium].png\n│ │ │ ├── font_unicode_range-font_unicode_ranges[firefox].png\n│ │ │ └── font_unicode_range-font_unicode_ranges[webkit].png\n│ │ ├── font_weight_test\n│ │ │ ├── font_weight-font_weights[chromium].png\n│ │ │ ├── font_weight-font_weights[firefox].png\n│ │ │ └── font_weight-font_weights[webkit].png\n│ │ ├── hello_app_test\n│ │ │ ├── hello_app-animation_demo_page[chromium].png\n│ │ │ ├── hello_app-animation_demo_page[firefox].png\n│ │ │ ├── hello_app-animation_demo_page[webkit].png\n│ │ │ ├── hello_app-dataframe_demo_page[chromium].png\n│ │ │ ├── hello_app-dataframe_demo_page[firefox].png\n│ │ │ ├── hello_app-dataframe_demo_page[webkit].png\n│ │ │ ├── hello_app-home_page[chromium].png\n│ │ │ ├── hello_app-home_page[firefox].png\n│ │ │ ├── hello_app-home_page[webkit].png\n│ │ │ ├── hello_app-plotting_demo_page[chromium].png\n│ │ │ ├── hello_app-plotting_demo_page[firefox].png\n│ │ │ ├── hello_app-plotting_demo_page[webkit].png\n│ │ │ ├── hello_app-print_media-landscape-sidebar_closed[dark_theme-chromium].png\n│ │ │ ├── hello_app-print_media-landscape-sidebar_closed[dark_theme-firefox].png\n... (9768 more entries omitted)",
"main_features": [
"Simple and Pythonic: Write beautiful, easy-to-read code",
"Fast, interactive prototyping: Let others interact with your data and provide feedback quickly",
"Live editing: See your app update instantly as you edit your script",
"Open-source and free: Join a vibrant community and contribute to Streamlit's future"
],
"metadata": {
"owner": "streamlit",
"default_branch": "develop",
"topics": [
"data-analysis",
"data-science",
"data-visualization",
"deep-learning",
"developer-tools",
"machine-learning",
"python",
"streamlit"
]
}
}
\ No newline at end of file
{
"repo_name": "vllm",
"repo_url": "https://github.com/vllm-project/vllm",
"stars": 86109,
"primary_language": "Python",
"updated_at": "2026-07-13T08:08:18Z",
"readme_text": "<!-- markdownlint-disable MD001 MD041 -->\n<p align=\"center\">\n <picture>\n <source media=\"(prefers-color-scheme: dark)\" srcset=\"https://raw.githubusercontent.com/vllm-project/vllm/main/docs/assets/logos/vllm-logo-text-dark.png\">\n <img alt=\"vLLM\" src=\"https://raw.githubusercontent.com/vllm-project/vllm/main/docs/assets/logos/vllm-logo-text-light.png\" width=55%>\n </picture>\n</p>\n\n<h3 align=\"center\">\nEasy, fast, and cheap LLM serving for everyone\n</h3>\n\n<p align=\"center\">\n| <a href=\"https://docs.vllm.ai\"><b>Documentation</b></a> | <a href=\"https://blog.vllm.ai/\"><b>Blog</b></a> | <a href=\"https://arxiv.org/abs/2309.06180\"><b>Paper</b></a> | <a href=\"https://x.com/vllm_project\"><b>Twitter/X</b></a> | <a href=\"https://discuss.vllm.ai\"><b>User Forum</b></a> | <a href=\"https://slack.vllm.ai\"><b>Developer Slack</b></a> |\n</p>\n\n🔥 We have built a vLLM website to help you get started with vLLM. Please visit [vllm.ai](https://vllm.ai) to learn more.\nFor events, please visit [vllm.ai/events](https://vllm.ai/events) to join us.\n\n---\n\n## About\n\nvLLM is a fast and easy-to-use library for LLM inference and serving.\n\nOriginally developed in the [Sky Computing Lab](https://sky.cs.berkeley.edu) at UC Berkeley, vLLM has grown into one of the most active open-source AI projects built and maintained by a diverse community of many dozens of academic institutions and companies from over 2000 contributors.\n\nvLLM is fast with:\n\n- State-of-the-art serving throughput\n- Efficient management of attention key and value memory with [**PagedAttention**](https://blog.vllm.ai/2023/06/20/vllm.html)\n- Continuous batching of incoming requests, chunked prefill, prefix caching\n- Fast and flexible model execution with piecewise and full CUDA/HIP graphs\n- Quantization: FP8, MXFP8/MXFP4, NVFP4, INT8, INT4, GPTQ/AWQ, GGUF, compressed-tensors, ModelOpt, TorchAO, and [more](https://docs.vllm.ai/en/latest/features/quantization/index.html)\n- Optimized attention kernels including FlashAttention, FlashInfer, TRTLLM-GEN, FlashMLA, and Triton\n- Optimized GEMM/MoE kernels for various precisions using CUTLASS, TRTLLM-GEN, CuTeDSL\n- Speculative decoding including n-gram, suffix, EAGLE, DFlash\n- Automatic kernel generation and graph-level transformations using torch.compile\n- Disaggregated prefill, decode, and encode\n\nvLLM is flexible and easy to use with:\n\n- Seamless integration with popular Hugging Face models\n- High-throughput serving with various decoding algorithms, including *parallel sampling*, *beam search*, and more\n- Tensor, pipeline, data, expert, and context parallelism for distributed inference\n- Streaming outputs\n- Generation of structured outputs using xgrammar or guidance\n- Tool calling and reasoning parsers\n- OpenAI-compatible API server, plus Anthropic Messages API and gRPC support\n- Efficient multi-LoRA support for dense and MoE layers\n- Support for NVIDIA GPUs, AMD GPUs, and x86/ARM/PowerPC CPUs. Additionally, diverse hardware plugins such as Google TPUs, Intel Gaudi, IBM Spyre, Huawei Ascend, Rebellions NPU, Apple Silicon, MetaX GPU, and more.\n\nvLLM seamlessly supports 200+ model architectures on Hugging Face, including:\n\n- Decoder-only LLMs (e.g., Llama, Qwen, Gemma)\n- Mixture-of-Expert LLMs (e.g., Mixtral, DeepSeek-V3, Qwen-MoE, GPT-OSS)\n- Hybrid attention and state-space models (e.g., Mamba, Qwen3.5)\n- Multi-modal models (e.g., LLaVA, Qwen-VL, Pixtral)\n- Embedding and retrieval models (e.g., E5-Mistral, GTE, ColBERT)\n- Reward and classification models (e.g., Qwen-Math)\n\nFind the full list of supported models [here](https://docs.vllm.ai/en/latest/models/supported_models.html).\n\n## Getting Started\n\nInstall vLLM with [`uv`](https://docs.astral.sh/uv/) (recommended) or `pip`:\n\n```bash\nuv pip install vllm\n```\n\nOr [build from source](https://docs.vllm.ai/en/latest/getting_started/installation/gpu/index.html#build-wheel-from-source) for development.\n\nVisit our [documentation](https://docs.vllm.ai/en/latest/) to learn more.\n\n- [Installation](https://docs.vllm.ai/en/latest/getting_started/installation.html)\n- [Quickstart](https://docs.vllm.ai/en/latest/getting_started/quickstart.html)\n- [List of Supported Models](https://docs.vllm.ai/en/latest/models/supported_models.html)\n\n## Contributing\n\nWe welcome and value any contributions and collaborations.\nPlease check out [Contributing to vLLM](https://docs.vllm.ai/en/latest/contributing/index.html) for how to get involved.\n\n## Citation\n\nIf you use vLLM for your research, please cite our [paper](https://arxiv.org/abs/2309.06180):\n\n```bibtex\n@inproceedings{kwon2023efficient,\n title={Efficient Memory Management for Large Language Model Serving with PagedAttention},\n author={Woosuk Kwon and Zhuohan Li and Siyuan Zhuang and Ying Sheng and Lianmin Zheng and Cody Hao Yu and Joseph E. Gonzalez and Hao Zhang and Ion Stoica},\n booktitle={Proceedings of the ACM SIGOPS 29th Symposium on Operating Systems Principles},\n year={2023}\n}\n```\n\n## Contact Us\n\n<!-- --8<-- [start:contact-us] -->\n- For technical questions and feature requests, please use GitHub [Issues](https://github.com/vllm-project/vllm/issues)\n- For discussing with fellow users, please use the [vLLM Forum](https://discuss.vllm.ai)\n- For coordinating contributions and development, please use [Slack](https://slack.vllm.ai)\n- For security disclosures, please use GitHub's [Security Advisories](https://github.com/vllm-project/vllm/security/advisories) feature\n- For collaborations and partnerships, please contact us at [collaboration@vllm.ai](mailto:collaboration@vllm.ai)\n<!-- --8<-- [end:contact-us] -->\n\n## Media Kit\n\n- If you wish to use vLLM's logo, please refer to [our media kit repo](https://github.com/vllm-project/media-kit)",
"directory_tree": "├── .buildkite\n│ ├── hardware_tests\n│ │ ├── intel_xpu_ci\n│ │ │ └── test-intel.yaml\n│ │ ├── amd.yaml\n│ │ ├── ascend_npu.yaml\n│ │ ├── cpu.yaml\n│ │ ├── gh200.yaml\n│ │ └── intel.yaml\n│ ├── image_build\n│ │ ├── image_build.sh\n│ │ ├── image_build.yaml\n│ │ ├── image_build_arm64.sh\n│ │ ├── image_build_cpu.sh\n│ │ ├── image_build_cpu_arm64.sh\n│ │ ├── image_build_hpu.sh\n│ │ ├── image_build_torch_nightly.sh\n│ │ └── image_build_xpu.sh\n│ ├── intel_jobs\n│ │ ├── basic_correctness.yaml\n│ │ ├── engine_intel.yaml\n│ │ ├── expert_parallelism_intel.yaml\n│ │ ├── kernels_intel.yaml\n│ │ ├── lora_intel.yaml\n│ │ ├── misc_intel.yaml\n│ │ ├── model_runner_v2_intel.yaml\n│ │ ├── models_distributed_intel.yaml\n│ │ ├── models_multimodal_intel.yaml\n│ │ ├── quantization.yaml\n│ │ └── test-intel.yaml\n│ ├── lm-eval-harness\n│ │ ├── configs\n│ │ │ ├── DeepSeek-V2-Lite-Chat.yaml\n│ │ │ ├── Meta-Llama-3-70B-Instruct-FBGEMM-nonuniform.yaml\n│ │ │ ├── Meta-Llama-3-70B-Instruct.yaml\n│ │ │ ├── Meta-Llama-3-8B-Instruct-Channelwise-compressed-tensors.yaml\n│ │ │ ├── Meta-Llama-3-8B-Instruct-FBGEMM-nonuniform.yaml\n│ │ │ ├── Meta-Llama-3-8B-Instruct-FP8-compressed-tensors.yaml\n│ │ │ ├── Meta-Llama-3-8B-Instruct-FP8.yaml\n│ │ │ ├── Meta-Llama-3-8B-Instruct-INT8-compressed-tensors-asym.yaml\n│ │ │ ├── Meta-Llama-3-8B-Instruct-INT8-compressed-tensors.yaml\n│ │ │ ├── Meta-Llama-3-8B-Instruct-nonuniform-compressed-tensors.yaml\n│ │ │ ├── Meta-Llama-3-8B-Instruct.yaml\n│ │ │ ├── Meta-Llama-3-8B-QQQ.yaml\n│ │ │ ├── Meta-Llama-3.2-1B-Instruct-FP8-compressed-tensors.yaml\n│ │ │ ├── Meta-Llama-3.2-1B-Instruct-INT8-compressed-tensors.yaml\n│ │ │ ├── Meta-Llama-4-Maverick-17B-128E-Instruct-FP8-MM.yaml\n│ │ │ ├── Meta-Llama-4-Maverick-17B-128E-Instruct-FP8.yaml\n│ │ │ ├── Minitron-4B-Base-FP8.yaml\n│ │ │ ├── Mixtral-8x22B-Instruct-v0.1-FP8-Dynamic.yaml\n│ │ │ ├── Mixtral-8x7B-Instruct-v0.1-FP8.yaml\n│ │ │ ├── Mixtral-8x7B-Instruct-v0.1.yaml\n│ │ │ ├── models-large-hopper.txt\n│ │ │ ├── models-large-rocm-fp8.txt\n│ │ │ ├── models-large-rocm.txt\n│ │ │ ├── models-large.txt\n│ │ │ ├── models-mm-large-h100.txt\n│ │ │ ├── models-mm-small.txt\n│ │ │ ├── models-small-rocm.txt\n│ │ │ ├── models-small.txt\n│ │ │ ├── NVIDIA-Nemotron-3-Nano-30B-A3B-BF16.yaml\n│ │ │ ├── NVIDIA-Nemotron-3-Nano-30B-A3B-FP8.yaml\n│ │ │ ├── Qwen1.5-MoE-W4A16-compressed-tensors.yaml\n│ │ │ ├── Qwen2-1.5B-Instruct-FP8W8.yaml\n│ │ │ ├── Qwen2-1.5B-Instruct-INT8-compressed-tensors.yaml\n│ │ │ ├── Qwen2-57B-A14-Instruct.yaml\n│ │ │ ├── Qwen2.5-1.5B-Instruct.yaml\n│ │ │ ├── Qwen2.5-VL-3B-Instruct-FP8-dynamic.yaml\n│ │ │ ├── Qwen2.5-VL-7B-Instruct.yaml\n│ │ │ └── Qwen3-235B-A22B-Instruct-2507-FP8.yaml\n│ │ ├── conftest.py\n│ │ ├── run-lm-eval-chartqa-vllm-vlm-baseline.sh\n│ │ ├── run-lm-eval-gsm-hf-baseline.sh\n│ │ ├── run-lm-eval-gsm-vllm-baseline.sh\n│ │ ├── run-lm-eval-mmlupro-vllm-baseline.sh\n│ │ └── test_lm_eval_correctness.py\n│ ├── performance-benchmarks\n│ │ ├── scripts\n│ │ │ ├── compare-json-results.py\n│ │ │ ├── convert-results-json-to-markdown.py\n│ │ │ ├── launch-server.sh\n│ │ │ └── run-performance-benchmarks.sh\n│ │ ├── tests\n│ │ │ ├── genai-perf-tests.json\n│ │ │ ├── latency-tests-arm64-cpu.json\n│ │ │ ├── latency-tests-cpu.json\n│ │ │ ├── latency-tests-hpu.json\n│ │ │ ├── latency-tests.json\n│ │ │ ├── nightly-tests.json\n│ │ │ ├── serving-tests-arm64-cpu.json\n│ │ │ ├── serving-tests-cpu-asr.json\n│ │ │ ├── serving-tests-cpu-embed.json\n│ │ │ ├── serving-tests-cpu-text.json\n│ │ │ ├── serving-tests-cpu.json\n│ │ │ ├── serving-tests-hpu.json\n│ │ │ ├── serving-tests.json\n│ │ │ ├── throughput-tests-arm64-cpu.json\n│ │ │ ├── throughput-tests-cpu.json\n│ │ │ ├── throughput-tests-hpu.json\n│ │ │ └── throughput-tests.json\n│ │ ├── performance-benchmarks-descriptions.md\n│ │ └── README.md\n│ ├── scripts\n│ │ ├── hardware_ci\n│ │ │ ├── run-amd-test.sh\n│ │ │ ├── run-cpu-compatibility-test.sh\n│ │ │ ├── run-cpu-distributed-smoke-test.sh\n│ │ │ ├── run-cpu-test-arm.sh\n│ │ │ ├── run-cpu-test-ppc64le.sh\n│ │ │ ├── run-cpu-test-s390x.sh\n│ │ │ ├── run-cpu-test.sh\n│ │ │ ├── run-gh200-test.sh\n│ │ │ ├── run-hpu-test.sh\n│ │ │ ├── run-intel-ci-test.sh\n│ │ │ ├── run-intel-test.sh\n│ │ │ ├── run-npu-test.sh\n│ │ │ ├── run-tpu-v1-test-part2.sh\n│ │ │ └── run-tpu-v1-test.sh\n│ │ ├── lib\n│ │ │ ├── manylinux.sh\n│ │ │ └── select-python.sh\n│ │ ├── rocm\n│ │ │ ├── build-ci-base.sh\n│ │ │ ├── build-test-image.sh\n│ │ │ ├── refresh-base-image.sh\n│ │ │ └── smoke-test-image.sh\n│ │ ├── scheduled_integration_test\n│ │ │ ├── deepseek_v2_lite_ep_eplb.sh\n│ │ │ ├── deepseek_v2_lite_prefetch_offload.sh\n│ │ │ ├── qwen30b_a3b_fp8_block_ep_eplb.sh\n│ │ │ ├── qwen30b_a3b_fp8_dp4_async_eplb.sh\n│ │ │ └── qwen3_next_mtp_async_eplb.sh\n│ │ ├── tool_call\n│ │ │ └── run-bfcl-eval.sh\n│ │ ├── tpu\n│ │ │ ├── cleanup_docker.sh\n│ │ │ ├── config_v6e_1.env\n│ │ │ ├── docker_run_bm.sh\n│ │ │ ├── quantized_v6e_1.env\n│ │ │ └── run_bm.sh\n│ │ ├── xpu\n│ │ │ ├── create-xpu-ecr-manifest.sh\n│ │ │ └── push-nightly-builds-xpu.sh\n│ │ ├── annotate-build-artifact.sh\n│ │ ├── annotate-image-build.sh\n│ │ ├── annotate-rocm-release.sh\n│ │ ├── cache-rocm-base-wheels.sh\n│ │ ├── check-ray-compatibility.sh\n│ │ ├── cherry-pick-from-milestone.sh\n│ │ ├── ci-bake-rocm.sh\n│ │ ├── ci-clean-log.sh\n│ │ ├── ci-fetch-log.sh\n│ │ ├── cleanup-nightly-builds.sh\n│ │ ├── detect-manylinux-tag.py\n│ │ ├── docker-build-metadata-args.sh\n│ │ ├── generate-and-upload-nightly-index.sh\n│ │ ├── generate-nightly-index.py\n│ │ ├── install-kv-connectors.sh\n│ │ ├── publish-release-images.sh\n│ │ ├── push-nightly-builds-rocm.sh\n│ │ ├── push-nightly-builds.sh\n│ │ ├── rerun-test.sh\n│ │ ├── run-benchmarks.sh\n│ │ ├── run-multi-node-test.sh\n│ │ ├── run-rust-frontend-cargo-ci.sh\n│ │ ├── trigger-ci-build.sh\n│ │ ├── upload-nightly-wheels.sh\n│ │ ├── upload-release-wheels-pypi.sh\n│ │ └── upload-rocm-wheels.sh\n│ ├── test_areas\n│ │ ├── attention.yaml\n│ │ ├── basic_correctness.yaml\n│ │ ├── benchmarks.yaml\n│ │ ├── compile.yaml\n│ │ ├── cuda.yaml\n│ │ ├── disaggregated.yaml\n│ │ ├── distributed.yaml\n│ │ ├── docker.yaml\n│ │ ├── e2e_integration.yaml\n│ │ ├── engine.yaml\n│ │ ├── entrypoints.yaml\n│ │ ├── expert_parallelism.yaml\n│ │ ├── kernels.yaml\n│ │ ├── lm_eval.yaml\n│ │ ├── lora.yaml\n│ │ ├── misc.yaml\n│ │ ├── model_executor.yaml\n│ │ ├── model_runner_v2.yaml\n│ │ ├── models_basic.yaml\n│ │ ├── models_distributed.yaml\n│ │ ├── models_language.yaml\n│ │ ├── models_multimodal.yaml\n│ │ ├── plugins.yaml\n│ │ ├── pytorch.yaml\n│ │ ├── quantization.yaml\n│ │ ├── ray_compat.yaml\n│ │ ├── rust_frontend.yaml\n│ │ ├── rust_frontend_cargo.yaml\n│ │ ├── samplers.yaml\n│ │ ├── spec_decode.yaml\n│ │ └── weight_loading.yaml\n│ ├── .pipeline_gen_v2\n│ ├── check-wheel-size.py\n│ ├── ci_config.yaml\n│ ├── ci_config_intel.yaml\n│ ├── ci_config_rocm.yaml\n│ ├── release-pipeline.yaml\n│ ├── test-amd.yaml\n│ └── test-pipeline.yaml\n├── .claude\n│ └── skills\n│ └── ci-fails-buildkite\n│ └── SKILL.md\n├── .gemini\n│ └── config.yaml\n├── .github\n│ ├── ISSUE_TEMPLATE\n│ │ ├── 100-documentation.yml\n│ │ ├── 200-installation.yml\n│ │ ├── 300-usage.yml\n│ │ ├── 400-bug-report.yml\n│ │ ├── 450-ci-failure.yml\n│ │ ├── 500-feature-request.yml\n│ │ ├── 600-new-model.yml\n│ │ ├── 700-performance-discussion.yml\n│ │ ├── 750-RFC.yml\n│ │ └── config.yml\n│ ├── workflows\n│ │ ├── matchers\n│ │ │ ├── actionlint.json\n│ │ │ ├── markdownlint.json\n│ │ │ └── mypy.json\n│ │ ├── scripts\n│ │ │ ├── build.sh\n│ │ │ ├── create_release.js\n│ │ │ ├── cuda-install.sh\n│ │ │ ├── env.sh\n│ │ │ └── pytorch-install.sh\n│ │ ├── add_label_automerge.yml\n│ │ ├── issue_autolabel.yml\n│ │ ├── macos-smoke-test.yml\n│ │ ├── new_pr_bot.yml\n│ │ ├── pre-commit.yml\n│ │ └── stale.yml\n│ ├── actionlint.yaml\n│ ├── CODEOWNERS\n│ ├── dependabot.yml\n│ ├── FUNDING.yml\n│ ├── mergify.yml\n│ ├── PULL_REQUEST_TEMPLATE.md\n│ └── scale-config.yml\n├── benchmarks\n│ ├── attention_benchmarks\n│ │ ├── configs\n│ │ │ ├── mla_decode.yaml\n│ │ │ ├── mla_fa4_fp8_output.yaml\n│ │ │ ├── mla_mixed_batch.yaml\n│ │ │ ├── mla_prefill.yaml\n│ │ │ ├── mla_sparse_decode.yaml\n│ │ │ ├── mla_sparse_prefill.yaml\n│ │ │ ├── reorder_threshold.yaml\n│ │ │ ├── speculative_decode.yaml\n│ │ │ ├── standard_attention.yaml\n│ │ │ ├── standard_decode.yaml\n│ │ │ └── standard_prefill.yaml\n│ │ ├── __init__.py\n│ │ ├── batch_spec.py\n│ │ ├── benchmark.py\n│ │ ├── common.py\n│ │ ├── mla_runner.py\n│ │ ├── README.md\n│ │ └── runner.py\n│ ├── auto_tune\n│ │ ├── auto_tune.sh\n│ │ ├── batch_auto_tune.sh\n│ │ └── README.md\n│ ├── cutlass_benchmarks\n│ │ ├── utils.py\n│ │ ├── w8a8_benchmarks.py\n│ │ └── weight_shapes.py\n│ ├── fused_kernels\n│ │ ├── layernorm_rms_benchmarks.py\n│ │ ├── merge_attn_states_benchmarks.py\n│ │ └── silu_mul_block_quant_benchmark.py\n│ ├── kernels\n│ │ ├── cpu\n│ │ │ ├── benchmark_cpu_attn.py\n│ │ │ └── benchmark_cpu_fused_moe.py\n│ │ ├── deepgemm\n│ │ │ ├── benchmark_fp8_block_dense_gemm.py\n│ │ │ └── README.md\n│ │ ├── ir\n│ │ │ ├── __init__.py\n│ │ │ ├── bench_ir_ops.py\n│ │ │ └── shapes.py\n│ │ ├── __init__.py\n│ │ ├── bench_concat_mla_q.py\n│ │ ├── bench_cp_gather_fp8.py\n│ │ ├── benchmark_2d_silu_mul_fp8_quant.py\n│ │ ├── benchmark_activation.py\n... (6374 more entries omitted)",
"main_features": [
"About",
"Citation",
"Contact Us",
"Media Kit"
],
"metadata": {
"owner": "vllm-project",
"default_branch": "main",
"topics": [
"amd",
"blackwell",
"cuda",
"deepseek",
"deepseek-v3",
"gpt",
"gpt-oss",
"inference",
"kimi",
"llama",
"llm",
"llm-serving",
"model-serving",
"moe",
"openai",
"pytorch",
"qwen",
"qwen3",
"tpu",
"transformer"
]
}
}
\ No newline at end of file
No preview for this file type
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑!
请 注册 或者 后发表评论