Most AI engineering courses teach you about the tools. These 20 AI engineering repos let you work with them: clone the code, run the examples, and read the internals of systems that carry real production workloads today. We grouped them into six layers of the modern stack, from training foundations to evaluation and ops, and pulled a live star count for each one.
The AI engineering repos below are ordered as a walk up the stack. Each entry names the maintainers, a star count captured on October 7, 2026, and one honest take on what the project gives you and when to reach for it. Counts age fast; the repos will still be there.
Model and Training Foundations
The ground floor: the framework and the model hub everything else builds on.
- Transformers (Hugging Face, 167k stars). One API across text, vision, and audio, with weights and model cards for hundreds of architectures. If you read a single codebase this year, make it this one: the trainer internals alone teach you how modern fine-tuning actually works.
- PyTorch (PyTorch Foundation, 104k stars). The framework underneath nearly every other project on this list. Beyond the tutorials, the interesting parts are torch.compile and the distributed runtimes, where the real engineering happens.
- PyTorch Lightning (Lightning AI, 31k stars). Strips the training loop boilerplate out of PyTorch so experiments stay comparable across runs. A good choice when you want checkpointing, logging, and multi-device support without writing your own framework.
Fine-Tuning and Distributed Training
The layer where a base model becomes your model, on hardware you can actually afford.
- PEFT (Hugging Face, 22k stars). Parameter-efficient fine-tuning: LoRA and its relatives adapt a large model by training tiny adapter weights instead of full checkpoints. This is what turns fine-tuning a 70B model into a single-GPU job, so start here before you rent a bigger cluster.
- TRL (Hugging Face, 19k stars). Training recipes for the post-pretraining stages: supervised fine-tuning, DPO, and RLHF, kept current against new model architectures. The shortest path from a base model to an instruction-following one.
- Accelerate (Hugging Face, 10k stars). The glue between your training script and the hardware it lands on: one code path for a single GPU, a multi-GPU node, or a TPU pod. Small API, large payoff the day a notebook script needs to scale.
- DeepSpeed (deepspeedai, 43k stars). Microsoft’s ZeRO optimizer sharding and pipeline parallelism, the machinery behind some of the largest training runs on record. Move here when the friendlier abstractions stop fitting your model in memory.
Inference and Serving
Weights on a disk are not a product. These three AI engineering repos turn them into endpoints.
- vLLM (vLLM project, 93k stars). PagedAttention and continuous batching made it the default for self-hosted LLM serving, and every rival engine has been chasing its throughput since. We compare it against the field in our serving engines deep dive.
- llama.cpp (ggml, 130k stars). Pure C and C++ inference for quantized models on laptops, desktops, and phones, no data center required. The project that proved a 4-bit quantized model is genuinely useful rather than a curiosity.
- ONNX Runtime (Microsoft, 22k stars). Cross-platform inference for ONNX graphs, tuned for CPUs, NPUs, and GPUs from servers down to edge devices. The escape hatch when your model needs to ship inside an application instead of behind an API.
RAG and Retrieval
Frameworks for grounding model answers in your own documents.
- LangChain (LangChain, 147k stars). The broadest integration surface in the ecosystem, which makes it the fastest way to prototype a retrieval pipeline even if you later outgrow parts of it. Its abstractions are worth knowing regardless of what you end up shipping.
- GraphRAG (Microsoft, 36k stars). Indexes your corpus into a knowledge graph so questions about themes and relationships become answerable, where plain vector search returns loose fragments. We mapped where graph retrieval fits in the advanced RAG techniques collection.
- Haystack (deepset, 27k stars). A deliberately production-shaped framework: declarative pipelines, mature document stores, and evaluation tooling designed in rather than bolted on. A strong candidate the day your RAG prototype graduates to a service.
- DSPy (Stanford NLP, 39k stars). Treats prompts as compiled programs: you declare the task and the metric, and its optimizers search for the prompt and demonstration sets that hit the metric. Changes how you think about prompting even if you never adopt it.
Agents
The orchestration layer, from one-file libraries to enterprise SDKs.
- LangGraph (LangChain, 43k stars). Models agent workflows as state machines with durable, checkpointed state and human-in-the-loop controls, which is what production agent loops actually need. We walked its free academy course in the LangGraph course review.
- Microsoft Agent Framework (Microsoft, 14k stars). The merger of Semantic Kernel and AutoGen into a single SDK for Python and .NET, aimed squarely at enterprise workflows. One to watch if your organization is Microsoft-native; it supersedes both predecessors.
- smolagents (Hugging Face, 30k stars). A deliberately tiny agent library where agents act by writing Python code instead of emitting JSON tool calls. Hugging Face built its agents course on it, and we rated that course the clearest entry point in the Hugging Face agents course review.
Evaluation, Monitoring, and Ops
The layer most side projects skip and most production systems cannot. These three AI engineering repos close it.
- Promptfoo (Promptfoo, 26k stars). Turns prompt changes into testable CI checks with assertions, model-graded evals, and red-team scanning. The cheapest insurance available for anything user-facing that depends on a prompt.
- Evidently (Evidently AI, 8k stars). Open-source evaluation and monitoring for ML and LLM systems, from data drift reports in a notebook to dashboards in production. A mature project that predates the current LLM wave, which shows in its depth.
- MLflow (MLflow, 28k stars). The default experiment tracker, now extended with LLM tracing, evaluation, and a gateway for serving. Gives you a single pane over runs, models, and prompts instead of one tool per concern.
How to Work Through These AI Engineering Repos
Resist the urge to skim all twenty in one sitting; the list is a map, not a syllabus. A loop that works: clone one of these AI engineering repos, run one example end to end, change one behavior, and build something small enough to finish in a weekend. One repo at a time beats a bookmark folder you never open.
Sequencing matters more than speed. If you are model-side, start with Transformers and PEFT, then take TRL into a real fine-tune. If you are platform-side, go straight to vLLM and put a quantized model behind an endpoint. If agents are your target, build one with smolagents to learn the loop, then graduate to LangGraph for the state handling. The evaluation tools slot in the moment anything you build meets a user.
Every hour spent modifying one of these AI engineering repos teaches more than an afternoon of reading about it. That is the whole reason this list favors repositories you can run over repositories you can only read.
If you only pick two from this list of AI engineering repos, take Transformers for the shared vocabulary of the field and vLLM for the shortest path from weights to a working endpoint. Add LangGraph the moment your project starts looking like an agent.