GitHub Jupyter Notebook Weekly Trending

oracle-devrel/oracle-ai-developer-hub

Technical resources for AI developers to build applications, agents, and systems using Oracle AI Database and OCI services

Oracle AI Developer Hub

This repository contains technical resources to help AI Developers and Engineers build AI applications, agents, and systems using Oracle AI Database and OCI services alongside other key components of the AI/Agent stack.

What You'll Find

This repository is organized into several key areas:

📱 Apps (`/apps`)

Applications and reference implementations demonstrating how to build AI-powered solutions with Oracle technologies. These complete, working examples showcase end-to-end implementations of AI applications, agents, and systems that leverage Oracle AI Database and OCI services. Each application includes source code, deployment configurations, and documentation to help developers understand architectural patterns, integration approaches, and best practices for building production-grade AI solutions.

Name	Description	Link
FitTracker	Gamified fitness platform built with Oracle 26ai JSON Duality Views (FastAPI + Redis), created live during a webinar.
agentic_rag	Intelligent RAG system with multi-agent Chain of Thought (CoT), PDF/Web/Repo processing, and Oracle AI Database 26ai integration
finance-ai-agent-demo	Financial services AI agent with Oracle AI Database as a unified memory core for vector, graph, spatial, and relational queries
oci-generative-ai-jet-ui	Full-stack AI application with Oracle JET UI, OCI Generative AI integration, Kubernetes deployment, and Terraform infrastructure
tanstack-shoe-store	AI chat app using TanStack Start and Oracle 26ai Select AI to query a shoe store database with natural language
oracle-data-migration-harness	AI agent harness that migrates a RAG corpus from MongoDB into Oracle AI Database 26ai while preserving vector search and unlocking SQL/JSON Duality queries

📓 Notebooks (`/notebooks`)

Jupyter notebooks and interactive tutorials covering:

AI/ML model development and experimentation
Oracle Database AI features and capabilities
OCI AI services integration patterns
Data preparation and analysis workflows
Agent development and orchestration examples

Name	Description	Stack
agentic_rag_langchain_oracledb_demo	Multi-agent RAG with langchain-oracledb: OracleVS, OracleEmbeddings, OracleTextSplitter, and CoT agents	Oracle AI Database, langchain-oracledb, Ollama
fs_vs_dbs	Compare filesystem vs database agent memory architectures.	LangChain, Oracle AI Database, OpenAI
memory_context_engineering_agents	Build AI agents with 6 types of persistent memory.	LangChain, Oracle AI Database, OpenAI, Tavily
oracle_langchain_example	Build a RAG application using Oracle 26ai vector storage and LangChain	Oracle AI Database, langchain-oracledb, HuggingFace
oracle_rag_agents_zero_to_hero	Learn to build RAG agents from scratch using Oracle AI Database.	Oracle AI Database, OpenAI, OpenAI Agents SDK
oracle_rag_with_evals	Build RAG systems with comprehensive evaluation metrics	Oracle AI Database, OpenAI, BEIR, Galileo
oracle_data_migration_harness_walkthrough	Walk through a MongoDB-to-Oracle AI Database migration harness with vector parity, verification, and JSON Relational Duality	Oracle AI Database 26ai, MongoDB, FastAPI, React, sentence-transformers
agent_reasoning_demo	Interactive demo of 11 cognitive architectures (CoT, ToT, ReAct, Self-Reflection, and more) for agent reasoning	Ollama, agent-reasoning
oracle_agentic_rag_hybrid_search	Agentic RAG with vector, keyword, and hybrid search in a single SQL query using LangGraph ReAct agent	Oracle AI Database, langchain-oracledb, LangGraph, OpenAI
f1_miami_strategy_oracle_26ai	F1 Miami GP strategy intelligence for 2026 — SQL, hybrid vector+keyword search, JSON documents, and property graph in one Oracle 26ai database using real FastF1 data	Oracle AI Database, FastF1, sentence-transformers, Plotly
multicloud/	AWS, Azure, Google Cloud, and MongoDB API samples running Oracle AI Database outside OCI	Oracle AI Database + AWS / Azure / Google / MongoDB

📚 Guides (`/guides`)

Comprehensive documentation, reference materials, and conference presentations covering AI agent architecture, reasoning strategies, and memory systems.

Name	Description	Link
Building the Brain and Backbone of Enterprise AI Agents	Advanced reasoning and infrastructure strategies for enterprise AI agents. Covers the 2026 agent stack (layered architecture), reasoning patterns (Chain of Thought, Tree of Thoughts, Self-Reflection, Least-to-Most, Decomposed Prompting), and context/belief updates. Presented at DevWeek SF 2026 by Nacho Martinez.
Memory Engineering: The Discipline Behind Memory Augmented Agents	Deep dive into memory engineering as a discipline for AI agents — the science of helping agents remember, reason, and act. Covers the memory ecosystem, form factors, and key disciplines shaping memory-augmented agents. Presented at DevWeek SF 2026 (Keynote) by Richmond Alake.
Agent Memory with Oracle AI Database	Agent memory architectures and Oracle AI Database as the memory core for AI agents. Presented at the AI Developer Conference hosted by DeepLearning.AI in April 2026 by Eli Schilling.

🧠 Agent Memory (`/notebooks/agent_memory`)

Notebooks focused on the Oracle AI Agent Memory package (oracleagentmemory) — the AI-Agent Memory Package built on top of Oracle AI Database. These notebooks demonstrate how to use Oracle AI Database as the unified memory core for AI agents, serving conversation history, durable facts, and entity state from a single converged engine instead of stitching together a vector DB, key-value store, and relational store.

The collection covers the package's developer guide, benchmarks against naive memory, and three end-to-end framework examples (OpenAI Agents SDK, Claude Agent SDK, LangGraph).

Name	Description	Stack
OAMP Developer Guide	Step-by-step guide to the `oracleagentmemory` API: connection, the three core primitives (users/agents, memories, threads), automatic extraction, and vector retrieval.	OAMP, LiteLLM
OAMP Benchmarks	Quantify token cost, latency, and response quality of OAMP vs. naive flat-history memory across 80 scripted turns with three agent variants.	OAMP, LiteLLM, OpenAI
Deep Research Agent	Build a deep research agent for human genome exploration that uses Tavily for live web search and Oracle AI Agent Memory for durable findings across sessions.	OpenAI Agents SDK, Tavily, OAMP
Supply Chain Assistant	A supply chain assistant that tracks shipment cargo via in-process tools and an MCP server, with shipment records and operational notes persisted in OAMP.	Claude Agent SDK, MCP, OAMP
Mortgage Approval Workflow	A deterministic mortgage approval workflow modeled as a LangGraph `StateGraph` where OAMP persists applicant data and audit trails so failed runs can resume.	LangGraph, OAMP

See the Agent Memory README for a recommended reading order, prerequisites, and Open-in-Colab links.

🎓 Workshops (`/workshops`)

Hands-on workshops and guided learning experiences that take developers from fundamentals to production patterns with Oracle AI Database. Each workshop is self-contained with a student notebook (TODO gaps to fill in), a complete reference notebook, step-by-step part guides, and a ready-to-run Codespaces / devcontainer environment with Oracle AI Database pre-configured. Workshops progress from information retrieval and RAG, through agentic systems and orchestration, to memory-augmented agents — together they cover the full stack for building AI applications on Oracle.

Pull a single workshop without cloning the whole hub — each workshop README includes git sparse-checkout instructions so you can fetch only the folder you need.

Name	Description	Stack
Information Retrieval to RAG	Build a Research Paper Assistant over 200 ArXiv papers by implementing five retrieval strategies (keyword, vector, hybrid, graph) and a full RAG pipeline wired to OCI GenAI.	Oracle AI Database, sentence-transformers, oracledb, OCI GenAI (xAI Grok 3 Fast)
From RAG to Agents	Extend the RAG pipeline into a multi-agent system — wrap retrieval as agent tools, compose orchestration, and add persistent session memory backed by Oracle.	Oracle AI Database, sentence-transformers, oracledb, OpenAI API (GPT-5), openai-agents
Agent Memory	Build memory-aware agents: implement a `MemoryManager` with six memory types in Oracle, apply context-engineering techniques, and compare agent runs with and without memory.	Oracle AI Database, langchain-oracledb, sentence-transformers, OCI GenAI, Tavily

🤝 Partners (`/partners`)

Notebooks and apps contributed by partners in the AI ecosystem. AI Developers can use these resources to understand how to use Oracle AI Database and OCI alongside tools such as LangChain, Galileo, LlamaIndex, and other popular AI/ML frameworks and platforms.

Name	Description	Stack	Link
Coming soon	Partner-contributed resources will be added here	-	-

Getting Started

Explore Applications: Start with the applications in /apps to see complete, working examples
Follow Workshops: Check /workshops for guided learning paths
Experiment with Notebooks: Use /notebooks for hands-on experimentation
Build Memory-Augmented Agents: Dive into /notebooks/agent_memory for the Oracle AI Agent Memory package
Reference Guides: Consult /guides for detailed documentation
Check Partner Resources: Explore /partners for integrations with popular AI tools and frameworks

Contributing

This project is open source. Please submit your contributions by forking this repository and submitting a pull request! Oracle appreciates any contributions that are made by the open-source community.

Development Setup

Before contributing, please set up pre-commit hooks to ensure code is automatically formatted:

Install pre-commit:
```
pip install pre-commit
```
Install additional dependencies (optional, includes pre-commit and ruff):
```
pip install -r requirements-dev.txt
```
Install pre-commit hooks:
```
pre-commit install
```
Optional: Format existing code:
```
pre-commit run --all-files
```

The pre-commit hooks will automatically format your code using:

Ruff for Python files (formatting and linting)
Prettier for JavaScript, TypeScript, JSON, YAML, and Markdown files

For more detailed information, see SETUP_PRE_COMMIT.md.

License

Licensed under the Universal Permissive License (UPL), Version 1.0.

See LICENSE for more details.

ORACLE AND ITS AFFILIATES DO NOT PROVIDE ANY WARRANTY WHATSOEVER, EXPRESS OR IMPLIED, FOR ANY SOFTWARE, MATERIAL OR CONTENT OF ANY KIND CONTAINED OR PRODUCED WITHIN THIS REPOSITORY, AND IN PARTICULAR SPECIFICALLY DISCLAIM ANY AND ALL IMPLIED WARRANTIES OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE. FURTHERMORE, ORACLE AND ITS AFFILIATES DO NOT REPRESENT THAT ANY CUSTOMARY SECURITY REVIEW HAS BEEN PERFORMED WITH RESPECT TO ANY SOFTWARE, MATERIAL OR CONTENT CONTAINED OR PRODUCED WITHIN THIS REPOSITORY. IN ADDITION, AND WITHOUT LIMITING THE FOREGOING, THIRD PARTIES MAY HAVE POSTED SOFTWARE, MATERIAL OR CONTENT TO THIS REPOSITORY WITHOUT ANY REVIEW. USE AT YOUR OWN RISK.

Note: This repository is actively maintained and updated with new resources, examples, and best practices for Oracle AI development.

rasbt/LLMs-from-scratch

Implement a ChatGPT-like LLM in PyTorch from scratch, step by step

Build a Large Language Model (From Scratch)

This repository contains the code for developing, pretraining, and finetuning a GPT-like LLM and is the official code repository for the book Build a Large Language Model (From Scratch).

In Build a Large Language Model (From Scratch), you'll learn and understand how large language models (LLMs) work from the inside out by coding them from the ground up, step by step. In this book, I'll guide you through creating your own LLM, explaining each stage with clear text, diagrams, and examples.

The method described in this book for training and developing your own small-but-functional model for educational purposes mirrors the approach used in creating large-scale foundational models such as those behind ChatGPT. In addition, this book includes code for loading the weights of larger pretrained models for finetuning.

Link to the official source code repository
Link to the book at Manning (the publisher's website)
Link to the book page on Amazon.com
ISBN 9781633437166

To download a copy of this repository, click on the Download ZIP button or execute the following command in your terminal:

git clone --depth 1 https://github.com/rasbt/LLMs-from-scratch.git

(If you downloaded the code bundle from the Manning website, please consider visiting the official code repository on GitHub at https://github.com/rasbt/LLMs-from-scratch for the latest updates.)

Please note that this README.md file is a Markdown (.md) file. If you have downloaded this code bundle from the Manning website and are viewing it on your local computer, I recommend using a Markdown editor or previewer for proper viewing. If you haven't installed a Markdown editor yet, Ghostwriter is a good free option.

You can alternatively view this and other files on GitHub at https://github.com/rasbt/LLMs-from-scratch in your browser, which renders Markdown automatically.

Tip: If you're seeking guidance on installing Python and Python packages and setting up your code environment, I suggest reading the README.md file located in the setup directory.

Troubleshooting Guide

Chapter Title	Main Code (for Quick Access)	All Code + Supplementary
Setup recommendations How to best read this book	-	-
Ch 1: Understanding Large Language Models	No code	-
Ch 2: Working with Text Data	- ch02.ipynb - dataloader.ipynb (summary) - exercise-solutions.ipynb	./ch02
Ch 3: Coding Attention Mechanisms	- ch03.ipynb - multihead-attention.ipynb (summary) - exercise-solutions.ipynb	./ch03
Ch 4: Implementing a GPT Model from Scratch	- ch04.ipynb - gpt.py (summary) - exercise-solutions.ipynb	./ch04
Ch 5: Pretraining on Unlabeled Data	- ch05.ipynb - gpt_train.py (summary) - gpt_generate.py (summary) - exercise-solutions.ipynb	./ch05
Ch 6: Finetuning for Text Classification	- ch06.ipynb - gpt_class_finetune.py - exercise-solutions.ipynb	./ch06
Ch 7: Finetuning to Follow Instructions	- ch07.ipynb - gpt_instruction_finetuning.py (summary) - ollama_evaluate.py (summary) - exercise-solutions.ipynb	./ch07
Appendix A: Introduction to PyTorch	- code-part1.ipynb - code-part2.ipynb - DDP-script.py - exercise-solutions.ipynb	./appendix-A
Appendix B: References and Further Reading	No code	./appendix-B
Appendix C: Exercise Solutions	- list of exercise solutions	./appendix-C
Appendix D: Adding Bells and Whistles to the Training Loop	- appendix-D.ipynb	./appendix-D
Appendix E: Parameter-efficient Finetuning with LoRA	- appendix-E.ipynb	./appendix-E

The mental model below summarizes the contents covered in this book.

Prerequisites

The most important prerequisite is a strong foundation in Python programming. With this knowledge, you will be well prepared to explore the fascinating world of LLMs and understand the concepts and code examples presented in this book.

If you have some experience with deep neural networks, you may find certain concepts more familiar, as LLMs are built upon these architectures.

This book uses PyTorch to implement the code from scratch without using any external LLM libraries. While proficiency in PyTorch is not a prerequisite, familiarity with PyTorch basics is certainly useful. If you are new to PyTorch, Appendix A provides a concise introduction to PyTorch. Alternatively, you may find my book, PyTorch in One Hour: From Tensors to Training Neural Networks on Multiple GPUs, helpful for learning about the essentials.

Hardware Requirements

The code in the main chapters of this book is designed to run on conventional laptops within a reasonable timeframe and does not require specialized hardware. This approach ensures that a wide audience can engage with the material. Additionally, the code automatically utilizes GPUs if they are available. (Please see the setup doc for additional recommendations.)

Video Course

A 17-hour and 15-minute companion video course where I code through each chapter of the book. The course is organized into chapters and sections that mirror the book's structure so that it can be used as a standalone alternative to the book or complementary code-along resource.

Companion Book / Sequel

Build A Reasoning Model (From Scratch), while a standalone book, can be considered as a sequel to Build A Large Language Model (From Scratch).

It starts with a pretrained model and implements different reasoning approaches, including inference-time scaling, reinforcement learning, and distillation, to improve the model's reasoning capabilities.

Similar to Build A Large Language Model (From Scratch), Build A Reasoning Model (From Scratch) takes a hands-on approach implementing these methods from scratch.

Amazon link (TBD)
Manning link
GitHub repository

Exercises

Each chapter of the book includes several exercises. The solutions are summarized in Appendix C, and the corresponding code notebooks are available in the main chapter folders of this repository (for example, ./ch02/01_main-chapter-code/exercise-solutions.ipynb.

In addition to the code exercises, you can download a free 170-page PDF titled Test Yourself On Build a Large Language Model (From Scratch) from the Manning website. It contains approximately 30 quiz questions and solutions per chapter to help you test your understanding.

Bonus Material

Several folders contain optional materials as a bonus for interested readers:

Setup
Chapter 2: Working With Text Data
Chapter 3: Coding Attention Mechanisms
- Comparing Efficient Multi-Head Attention Implementations
- Understanding PyTorch Buffers
Chapter 4: Implementing a GPT Model From Scratch
Chapter 5: Pretraining on Unlabeled Data
Chapter 6: Finetuning for classification
Chapter 7: Finetuning to follow instructions

More bonus material from the Reasoning From Scratch repository:

Qwen3 (From Scratch) Basics
- Qwen3 Source Code Walkthrough
- Optimized Qwen3
Evaluation
Inference Scaling
- Self-Consistency
- Self-Refinement
Reinforcement Learning (RL)
- RLVR with GRPO From Scratch

Questions, Feedback, and Contributing to This Repository

I welcome all sorts of feedback, best shared via the Manning Forum or GitHub Discussions. Likewise, if you have any questions or just want to bounce ideas off others, please don't hesitate to post these in the forum as well.

Please note that since this repository contains the code corresponding to a print book, I currently cannot accept contributions that would extend the contents of the main chapter code, as it would introduce deviations from the physical book. Keeping it consistent helps ensure a smooth experience for everyone.

Citation

If you find this book or code useful for your research, please consider citing it.

Chicago-style citation:

Raschka, Sebastian. Build A Large Language Model (From Scratch). Manning, 2024. ISBN: 978-1633437166.

BibTeX entry:

@book{build-llms-from-scratch-book,
  author       = {Sebastian Raschka},
  title        = {Build A Large Language Model (From Scratch)},
  publisher    = {Manning},
  year         = {2024},
  isbn         = {978-1633437166},
  url          = {https://www.manning.com/books/build-a-large-language-model-from-scratch},
  github       = {https://github.com/rasbt/LLMs-from-scratch}
}

openai/openai-cookbook

Examples and guides for using the OpenAI API

✨ Navigate at cookbook.openai.com

Example code and guides for accomplishing common tasks with the OpenAI API. To run these examples, you'll need an OpenAI account and associated API key (create a free account here). Set an environment variable called OPENAI_API_KEY with your API key. Alternatively, in most IDEs such as Visual Studio Code, you can create an .env file at the root of your repo containing OPENAI_API_KEY=<your API key>, which will be picked up by the notebooks.

Most code examples are written in Python, though the concepts can be applied in any language.

For other useful tools, guides and courses, check out these related resources from around the web.

License

MIT License

HandsOnLLM/Hands-On-Large-Language-Models

Official code repo for the O'Reilly Book - "Hands-On Large Language Models"

# Hands-On Large Language Models

Welcome! In this repository you will find the code for all examples throughout the book Hands-On Large Language Models written by Jay Alammar and Maarten Grootendorst which we playfully dubbed:

"The Illustrated LLM Book"

Through the visually educational nature of this book and with almost 300 custom made figures, learn the practical tools and concepts you need to use Large Language Models today!

The book is available on:

We advise to run all examples through Google Colab for the easiest setup. Google Colab allows you to use a T4 GPU with 16GB of VRAM for free. All examples were mainly built and tested using Google Colab, so it should be the most stable platform. However, any other cloud provider should work.

Chapter	Notebook
Chapter 1: Introduction to Language Models
Chapter 2: Tokens and Embeddings
Chapter 3: Looking Inside Transformer LLMs
Chapter 4: Text Classification
Chapter 5: Text Clustering and Topic Modeling
Chapter 6: Prompt Engineering
Chapter 7: Advanced Text Generation Techniques and Tools
Chapter 8: Semantic Search and Retrieval-Augmented Generation
Chapter 9: Multimodal Large Language Models
Chapter 10: Creating Text Embedding Models
Chapter 11: Fine-tuning Representation Models for Classification
Chapter 12: Fine-tuning Generation Models

Tip

You can check the setup folder for a quick-start guide to install all packages locally and you can check the conda folder for a complete guide on how to setup your environment, including conda and PyTorch installation. Note that the depending on your OS, Python version, and dependencies your results might be slightly differ. However, they should this be similar to the examples in the book.

Reviews

"Jay and Maarten have continued their tradition of providing beautifully illustrated and insightful descriptions of complex topics in their new book. Bolstered with working code, timelines, and references to key papers, their book is a valuable resource for anyone looking to understand the main techniques behind how Large Language Models are built."

Andrew Ng - founder of DeepLearning.AI

"This is an exceptional guide to the world of language models and their practical applications in industry. Its highly-visual coverage of generative, representational, and retrieval applications of language models empowers readers to quickly understand, use, and refine LLMs. Highly recommended!"

Nils Reimers - Director of Machine Learning at Cohere | creator of sentence-transformers

"I can’t think of another book that is more important to read right now. On every single page, I learned something that is critical to success in this era of language models."

Josh Starmer - StatQuest

"If you’re looking to get up to speed in everything regarding LLMs, look no further! In this wonderful book, Jay and Maarten will take you from zero to expert in the history and latest advances in large language models. With very intuitive explanations, great real-life examples, clear illustrations, and comprehensive code labs, this book lifts the curtain on the complexities of transformer models, tokenizers, semantic search, RAG, and many other cutting-edge technologies. A must read for anyone interested in the latest AI technology!"

Luis Serrano, PhD - Founder and CEO of Serrano Academy

"Hands-On Large Language Models brings clarity and practical examples to cut through the hype of AI. It provides a wealth of great diagrams and visual aids to supplement the clear explanations. The worked examples and code make concrete what other books leave abstract. The book starts with simple introductory beginnings, and steadily builds in scope. By the final chapters, you will be fine-tuning and building your own large language models with confidence."

Leland McInnes - Researcher at the Tutte Institute for Mathematics and Computing | creator of UMAP and HDBSCAN

Bonus content!

We attempted to put as much information into the book without it being overwhelming. However, even with a 400-page book there is still much to discover!

We continue to create more guides that compliment the book and go more in-depth into new and exciting topics:

A Visual Guide to Mamba	A Visual Guide to Quantization	The Illustrated Stable Diffusion

A Visual Guide to Mixture of Experts	A Visual Guide to Reasoning LLMs	The Illustrated DeepSeek-R1

Citation

Please consider citing the book if you consider it useful for your research:

@book{hands-on-llms-book,
  author       = {Jay Alammar and Maarten Grootendorst},
  title        = {Hands-On Large Language Models},
  publisher    = {O'Reilly},
  year         = {2024},
  isbn         = {978-1098150969},
  url          = {https://www.oreilly.com/library/view/hands-on-large-language/9781098150952/},
  github       = {https://github.com/HandsOnLLM/Hands-On-Large-Language-Models}
}

anthropics/courses

Anthropic's educational courses

Anthropic courses

Welcome to Anthropic's educational courses. This repository currently contains five courses. We suggest completing the courses in the following order:

Anthropic API fundamentals - teaches the essentials of working with the Claude SDK: getting an API key, working with model parameters, writing multimodal prompts, streaming responses, etc.
Prompt engineering interactive tutorial - a comprehensive step-by-step guide to key prompting techniques. [AWS Workshop version]
Real world prompting - learn how to incorporate prompting techniques into complex, real world prompts. [Google Vertex version]
Prompt evaluations - learn how to write production prompt evaluations to measure the quality of your prompts.
Tool use - teaches everything you need to know to implement tool use successfully in your workflows with Claude.

Please note that these courses often favor our lowest-cost model, Claude 3 Haiku, to keep API costs down for students following along with the materials. Feel free to use other Claude models if you prefer.

microsoft/generative-ai-for-beginners

21 Lessons, Get Started Building with Generative AI

21 Lessons teaching everything you need to know to start building Generative AI applications

🌐 Multi-Language Support

Supported via GitHub Action (Automated & Always Up-to-Date)

Prefer to Clone Locally?

This repository includes 50+ language translations which significantly increases the download size. To clone without translations, use sparse checkout:

Bash / macOS / Linux:
git clone --filter=blob:none --sparse https://github.com/microsoft/generative-ai-for-beginners.git
cd generative-ai-for-beginners
git sparse-checkout set --no-cone '/*' '!translations' '!translated_images'
CMD (Windows):
git clone --filter=blob:none --sparse https://github.com/microsoft/generative-ai-for-beginners.git
cd generative-ai-for-beginners
git sparse-checkout set --no-cone "/*" "!translations" "!translated_images"
This gives you everything you need to complete the course with a much faster download.

Generative AI for Beginners (Version 3) - A Course

Learn the fundamentals of building Generative AI applications with our 21-lesson comprehensive course by Microsoft Cloud Advocates.

🌱 Getting Started

This course has 21 lessons. Each lesson covers its own topic so start wherever you like!

Lessons are labeled either "Learn" lessons explaining a Generative AI concept or "Build" lessons that explain a concept and code examples in both Python and TypeScript when possible.

For .NET Developers checkout Generative AI for Beginners (.NET Edition)!

Each lesson also includes a "Keep Learning" section with additional learning tools.

What You Need

To run the code of this course, you can use either:

Azure OpenAI Service - Lessons: "aoai-assignment"
GitHub Marketplace Model Catalog - Lessons: "githubmodels"
OpenAI API - Lessons: "oai-assignment"
Basic knowledge of Python or TypeScript is helpful - *For absolute beginners check out these Python and TypeScript courses
A GitHub account to fork this entire repo to your own GitHub account

We have created a Course Setup lesson to help you with setting up your development environment.

Don't forget to star (🌟) this repo to find it easier later.

🧠 Ready to Deploy?

If you are looking for more advanced code samples, check out our collection of Generative AI Code Samples in both Python and TypeScript.

🗣️ Meet Other Learners, Get Support

Join our official Azure AI Foundry Discord server to meet and network with other learners taking this course and get support.

Ask questions or share product feedback in our Azure AI Foundry Developer Forum on Github.

🚀 Building a Startup?

Visit Microsoft for Startups to find out how to get started building with Azure credits today.

🙏 Want to help?

Do you have suggestions or found spelling or code errors? Raise an issue or Create a pull request

📂 Each lesson includes:

A short video introduction to the topic
A written lesson located in the README
Python and TypeScript code samples supporting Azure OpenAI and OpenAI API
Links to extra resources to continue your learning

🗃️ Lessons

#	Lesson Link	Description	Video	Extra Learning
00	Course Setup	Learn: How to Setup Your Development Environment	Video Coming Soon	Learn More
01	Introduction to Generative AI and LLMs	Learn: Understanding what Generative AI is and how Large Language Models (LLMs) work.	Video	Learn More
02	Exploring and comparing different LLMs	Learn: How to select the right model for your use case	Video	Learn More
03	Using Generative AI Responsibly	Learn: How to build Generative AI Applications responsibly	Video	Learn More
04	Understanding Prompt Engineering Fundamentals	Learn: Hands-on Prompt Engineering Best Practices	Video	Learn More
05	Creating Advanced Prompts	Learn: How to apply prompt engineering techniques that improve the outcome of your prompts.	Video	Learn More
06	Building Text Generation Applications	Build: A text generation app using Azure OpenAI / OpenAI API	Video	Learn More
07	Building Chat Applications	Build: Techniques for efficiently building and integrating chat applications.	Video	Learn More
08	Building Search Apps Vector Databases	Build: A search application that uses Embeddings to search for data.	Video	Learn More
09	Building Image Generation Applications	Build: An image generation application	Video	Learn More
10	Building Low Code AI Applications	Build: A Generative AI application using Low Code tools	Video	Learn More
11	Integrating External Applications with Function Calling	Build: What is function calling and its use cases for applications	Video	Learn More
12	Designing UX for AI Applications	Learn: How to apply UX design principles when developing Generative AI Applications	Video	Learn More
13	Securing Your Generative AI Applications	Learn: The threats and risks to AI systems and methods to secure these systems.	Video	Learn More
14	The Generative AI Application Lifecycle	Learn: The tools and metrics to manage the LLM Lifecycle and LLMOps	Video	Learn More
15	Retrieval Augmented Generation (RAG) and Vector Databases	Build: An application using a RAG Framework to retrieve embeddings from a Vector Databases	Video	Learn More
16	Open Source Models and Hugging Face	Build: An application using open source models available on Hugging Face	Video	Learn More
17	AI Agents	Build: An application using an AI Agent Framework	Video	Learn More
18	Fine-Tuning LLMs	Learn: The what, why and how of fine-tuning LLMs	Video	Learn More
19	Building with SLMs	Learn: The benefits of building with Small Language Models	Video Coming Soon	Learn More
20	Building with Mistral Models	Learn: The features and differences of the Mistral Family Models	Video Coming Soon	Learn More
21	Building with Meta Models	Learn: The features and differences of the Meta Family Models	Video Coming Soon	Learn More

🌟 Special thanks

Special thanks to John Aziz for creating all of the GitHub Actions and workflows

Bernhard Merkle for making key contributions to each lesson to improve the learner and code experience.

🎒 Other Courses

Our team produces other courses! Check out:

LangChain

Azure / Edge / MCP / Agents

Generative AI Series

Core Learning

Copilot Series

Getting Help

If you get stuck or have any questions about building AI apps. Join fellow learners and experienced developers in discussions about MCP. It's a supportive community where questions are welcome and knowledge is shared freely.

If you have product feedback or errors while building visit:

duoan/TorchCode

🔥 LeetCode for PyTorch — practice implementing softmax, attention, GPT-2 and more from scratch with instant auto-grading. Jupyter-based, self-hosted or try online.

title: TorchCode emoji: 🔥 colorFrom: red colorTo: yellow sdk: docker app_port: 7860 pinned: false

🔥 TorchCode

Crack the PyTorch interview.

Practice implementing operators and architectures from scratch — the exact skills top ML teams test for.

Like LeetCode, but for tensors. Self-hosted. Jupyter-based. Instant feedback.

🎯 Why TorchCode?

Top companies (Meta, Google DeepMind, OpenAI, etc.) expect ML engineers to implement core operations from memory on a whiteboard. Reading papers isn't enough — you need to write softmax, LayerNorm, MultiHeadAttention, and full Transformer blocks code.

TorchCode gives you a structured practice environment with:

	Feature
🧩	40 curated problems	The most frequently asked PyTorch interview topics
⚖️	Automated judge	Correctness checks, gradient verification, and timing
🎨	Instant feedback	Colored pass/fail per test case, just like competitive programming
💡	Hints when stuck	Nudges without full spoilers
📖	Reference solutions	Study optimal implementations after your attempt
📊	Progress tracking	What you've solved, best times, and attempt counts
🔄	One-click reset	Toolbar button to reset any notebook back to its blank template — practice the same problem as many times as you want
	Open in Colab	Every notebook has an "Open in Colab" badge + toolbar button — run problems in Google Colab with zero setup

No cloud. No signup. No GPU needed. Just make run — or try it instantly on Hugging Face.

🚀 Quick Start

Option 0 — Try it online (zero install)

Launch on Hugging Face Spaces — opens a full JupyterLab environment in your browser. Nothing to install.

Or open any problem directly in Google Colab — every notebook has an badge.

Option 0b — Use the judge in Colab (pip)

In Google Colab, install the judge from PyPI so you can run check(...) without cloning the repo:

!pip install torch-judge

Then in a notebook cell:

from torch_judge import check, status, hint, reset_progress
status()           # list all problems and your progress
check("relu")      # run tests for the "relu" task
hint("relu")       # show a hint

Option 1 — Pull the pre-built image (fastest)

docker run -p 8888:8888 -e PORT=8888 ghcr.io/duoan/torchcode:latest

If the registry image is unavailable for your platform, use Option 2 instead. This is the common path on Apple Silicon / arm64.

Option 2 — Build locally

make run

make run will try the prebuilt image first and automatically fall back to a local build when needed.

Open http://localhost:8888 — that's it. Works with both Docker and Podman (auto-detected).

📋 Problem Set

Frequency: 🔥 = very likely in interviews, ⭐ = commonly asked, 💡 = emerging / differentiator

🧱 Fundamentals — "Implement X from scratch"

The bread and butter of ML coding interviews. You'll be asked to write these without torch.nn.

#	Problem	What You'll Implement	Freq	Key Concepts
1	ReLU	`relu(x)`	🔥	Activation functions, element-wise ops
2	Softmax	`my_softmax(x, dim)`	🔥	Numerical stability, exp/log tricks
16	Cross-Entropy Loss	`cross_entropy_loss(logits, targets)`	🔥	Log-softmax, logsumexp trick
17	Dropout	`MyDropout` (nn.Module)	🔥	Train/eval mode, inverted scaling
18	Embedding	`MyEmbedding` (nn.Module)	🔥	Lookup table, `weight[indices]`
19	GELU	`my_gelu(x)`	⭐	Gaussian error linear unit, `torch.erf`
20	Kaiming Init	`kaiming_init(weight)`	⭐	`std = sqrt(2/fan_in)`, variance scaling
21	Gradient Clipping	`clip_grad_norm(params, max_norm)`	⭐	Norm-based clipping, direction preservation
31	Gradient Accumulation	`accumulated_step(model, opt, ...)`	💡	Micro-batching, loss scaling
40	Linear Regression	`LinearRegression` (3 methods)	🔥	Normal equation, GD from scratch, nn.Linear
3	Linear Layer	`SimpleLinear` (nn.Module)	🔥	`y = xW^T + b`, Kaiming init, `nn.Parameter`
4	LayerNorm	`my_layer_norm(x, γ, β)`	🔥	Normalization, running stats, affine transform
7	BatchNorm	`my_batch_norm(x, γ, β)`	⭐	Batch vs layer statistics, train/eval behavior
8	RMSNorm	`rms_norm(x, weight)`	⭐	LLaMA-style norm, simpler than LayerNorm
15	SwiGLU MLP	`SwiGLUMLP` (nn.Module)	⭐	Gated FFN, `SiLU(gate) * up`, LLaMA/Mistral-style
22	Conv2d	`my_conv2d(x, weight, ...)`	🔥	Convolution, unfold, stride/padding

🧠 Attention Mechanisms — The heart of modern ML interviews

If you're interviewing for any role touching LLMs or Transformers, expect at least one of these.

#	Problem	What You'll Implement	Freq	Key Concepts
23	Cross-Attention	`MultiHeadCrossAttention` (nn.Module)	⭐	Encoder-decoder, Q from decoder, K/V from encoder
5	Scaled Dot-Product Attention	`scaled_dot_product_attention(Q, K, V)`	🔥	`softmax(QK^T/√d_k)V`, the foundation of everything
6	Multi-Head Attention	`MultiHeadAttention` (nn.Module)	🔥	Parallel heads, split/concat, projection matrices
9	Causal Self-Attention	`causal_attention(Q, K, V)`	🔥	Autoregressive masking with `-inf`, GPT-style
10	Grouped Query Attention	`GroupQueryAttention` (nn.Module)	⭐	GQA (LLaMA 2), KV sharing across heads
11	Sliding Window Attention	`sliding_window_attention(Q, K, V, w)`	⭐	Mistral-style local attention, O(n·w) complexity
12	Linear Attention	`linear_attention(Q, K, V)`	💡	Kernel trick, `φ(Q)(φ(K)^TV)`, O(n·d²)
14	KV Cache Attention	`KVCacheAttention` (nn.Module)	🔥	Incremental decoding, cache K/V, prefill vs decode
24	RoPE	`apply_rope(q, k)`	🔥	Rotary position embedding, relative position via rotation
25	Flash Attention	`flash_attention(Q, K, V, block_size)`	💡	Tiled attention, online softmax, memory-efficient

🏗️ Architecture & Adaptation — Put it all together

#	Problem	What You'll Implement	Freq	Key Concepts
26	LoRA	`LoRALinear` (nn.Module)	⭐	Low-rank adaptation, frozen base + `BA` update
27	ViT Patch Embedding	`PatchEmbedding` (nn.Module)	💡	Image → patches → linear projection
13	GPT-2 Block	`GPT2Block` (nn.Module)	⭐	Pre-norm, causal MHA + MLP (4x, GELU), residual connections
28	Mixture of Experts	`MixtureOfExperts` (nn.Module)	⭐	Mixtral-style, top-k routing, expert MLPs

⚙️ Training & Optimization

#	Problem	What You'll Implement	Difficulty	Freq	Key Concepts
29	Adam Optimizer	`MyAdam`		⭐	Momentum + RMSProp, bias correction
30	Cosine LR Scheduler	`cosine_lr_schedule(step, ...)`		⭐	Linear warmup + cosine annealing

🎯 Inference & Decoding

#	Problem	What You'll Implement	Freq	Key Concepts
32	Top-k / Top-p Sampling	`sample_top_k_top_p(logits, ...)`	🔥	Nucleus sampling, temperature scaling
33	Beam Search	`beam_search(log_prob_fn, ...)`	🔥	Hypothesis expansion, pruning, eos handling
34	Speculative Decoding	`speculative_decode(target, draft, ...)`	💡	Accept/reject, draft model acceleration

🔬 Advanced — Differentiators

#	Problem	What You'll Implement	Freq	Key Concepts
35	BPE Tokenizer	`SimpleBPE`	💡	Byte-pair encoding, merge rules, subword splits
36	INT8 Quantization	`Int8Linear` (nn.Module)	💡	Per-channel quantize, scale/zero-point, buffer vs param
37	DPO Loss	`dpo_loss(chosen, rejected, ...)`	💡	Direct preference optimization, alignment training
38	GRPO Loss	`grpo_loss(logps, rewards, group_ids, eps)`	💡	Group relative policy optimization, RLAIF, within-group normalized advantages
39	PPO Loss	`ppo_loss(new_logps, old_logps, advantages, clip_ratio)`	💡	PPO clipped surrogate loss, policy gradient, trust region

⚙️ How It Works

Each problem has two notebooks:

File	Purpose
`01_relu.ipynb`	✏️ Blank template — write your code here
`01_relu_solution.ipynb`	📖 Reference solution — check when stuck

Workflow

1. Open a blank notebook           →  Read the problem description
2. Implement your solution         →  Use only basic PyTorch ops
3. Debug freely                    →  print(x.shape), check gradients, etc.
4. Run the judge cell              →  check("relu")
5. See instant colored feedback    →  ✅ pass / ❌ fail per test case
6. Stuck? Get a nudge              →  hint("relu")
7. Review the reference solution   →  01_relu_solution.ipynb
8. Click 🔄 Reset in the toolbar  →  Blank slate — practice again!

In-Notebook API

from torch_judge import check, hint, status

check("relu")               # Judge your implementation
hint("causal_attention")    # Get a hint without full spoiler
status()                    # Progress dashboard — solved / attempted / todo

📅 Suggested Study Plan

Total: ~12–16 hours spread across 3–4 weeks. Perfect for interview prep on a deadline.

Week	Focus	Problems	Time
1	🧱 Foundations	ReLU → Softmax → CE Loss → Dropout → Embedding → GELU → Linear → LayerNorm → BatchNorm → RMSNorm → SwiGLU MLP → Conv2d	2–3 hrs
2	🧠 Attention Deep Dive	SDPA → MHA → Cross-Attn → Causal → GQA → KV Cache → Sliding Window → RoPE → Linear Attn → Flash Attn	3–4 hrs
3	🏗️ Architecture + Training	GPT-2 Block → LoRA → MoE → ViT Patch → Adam → Cosine LR → Grad Clip → Grad Accumulation → Kaiming Init	3–4 hrs
4	🎯 Inference + Advanced	Top-k/p Sampling → Beam Search → Speculative Decoding → BPE → INT8 Quant → DPO Loss → GRPO Loss → PPO Loss + speed run	3–4 hrs

🏛️ Architecture

┌──────────────────────────────────────────┐
│           Docker / Podman Container      │
│                                          │
│  JupyterLab (:8888)                      │
│    ├── templates/  (reset on each run)   │
│    ├── solutions/  (reference impl)      │
│    ├── torch_judge/ (auto-grading)       │
│    ├── torchcode-labext (JLab plugin)    │
│    │     🔄 Reset — restore template     │
│    │     🔗 Colab — open in Colab        │
│    └── PyTorch (CPU), NumPy              │
│                                          │
│  Judge checks:                           │
│    ✓ Output correctness (allclose)       │
│    ✓ Gradient flow (autograd)            │
│    ✓ Shape consistency                   │
│    ✓ Edge cases & numerical stability    │
└──────────────────────────────────────────┘

Single container. Single port. No database. No frontend framework. No GPU.

🛠️ Commands

make run    # Build & start (http://localhost:8888)
make stop   # Stop the container
make clean  # Stop + remove volumes + reset all progress

🧩 Adding Your Own Problems

TorchCode uses auto-discovery — just drop a new file in torch_judge/tasks/:

TASK = {
    "id": "my_task",
    "title": "My Custom Problem",
    "difficulty": "medium",
    "function_name": "my_function",
    "hint": "Think about broadcasting...",
    "tests": [ ... ],
}

No registration needed. The judge picks it up automatically.

📦 Publishing `torch-judge` to PyPI (maintainers)

The judge is published as a separate package so Colab/users can pip install torch-judge without cloning the repo.

Automatic (GitHub Action)

Pushing to master after changing the package version triggers .github/workflows/pypi-publish.yml, which builds and uploads to PyPI. No git tag is required.

Bump version in torch_judge/_version.py (e.g. __version__ = "0.1.1").
Configure PyPI Trusted Publisher (one-time):
- PyPI → Your project torch-judge → Publishing → Add a new pending publisher
- Owner: duoan, Repository: TorchCode, Workflow: pypi-publish.yml, Environment: (leave empty)
- Run the workflow once (push a version bump to master or Actions → Publish torch-judge to PyPI → Run workflow); PyPI will then link the publisher.
Release: commit the version bump and git push origin master.

Alternatively, use an API token: add repository secret PYPI_API_TOKEN (value = pypi-... from PyPI) and set TWINE_USERNAME=__token__ and TWINE_PASSWORD from that secret in the workflow if you prefer not to use Trusted Publishing.

Manual

pip install build twine
python -m build
twine upload dist/*

Version is in torch_judge/_version.py; bump it before each release.

❓ FAQ

Do I need a GPU?

No. Everything runs on CPU. The problems test correctness and understanding, not throughput.

Can I keep my solutions between runs?

Blank templates reset on every make run so you practice from scratch. Save your work under a different filename if you want to keep it. You can also click the 🔄 Reset button in the notebook toolbar at any time to restore the blank template without restarting.

Can I use Google Colab instead?

Yes! Every notebook has an Open in Colab badge at the top. Click it to open the problem directly in Google Colab — no Docker or local setup needed. You can also use the Colab toolbar button inside JupyterLab.

How are solutions graded?

The judge runs your function against multiple test cases using torch.allclose for numerical correctness, verifies gradients flow properly via autograd, and checks edge cases specific to each operation.

Who is this for?

Anyone preparing for ML/AI engineering interviews at top tech companies, or anyone who wants to deeply understand how PyTorch operations work under the hood.

🤝 Contributors

Thanks to everyone who has contributed to TorchCode.

_duoan

_Ando233

_ThierryHJ

Auto-generated from the GitHub contributors graph with avatars and GitHub usernames.

Built for engineers who want to deeply understand what they build.

If this helped your interview prep, consider giving it a ⭐

☕ Buy Me a Coffee

Scan to support

google-gemini/cookbook

Examples and guides for using the Gemini API

Welcome to the Gemini API Cookbook

This cookbook provides a structured learning path for using the Gemini API, focusing on hands-on tutorials and practical examples.

For comprehensive API documentation, visit ai.google.dev.

For Gemma quickstarts and examples, check out the Gemma cookbook.

Gemini 3: For the most recent updates on our latest generation, please check the Get Started and the thinking guides who include migration guides.

🍌 Nano-Banana 2: Go bananas with our latest image generation model: Nano-Banana 2. Get started here with 512px, thinking, search and image grounding, and a ton of examples!

🎶 Lyria 3: Channel your inner composer with Lyria 3. Get started here with 30s clips and full song generation, image-to-music, and a ton of examples!

Navigating the Cookbook

This cookbook is organized into two main categories:

Quick Starts: Step-by-step guides covering both introductory topics ("Get Started ") and specific API features.
Examples: Practical use cases demonstrating how to combine multiple features.

We also showcase Demos in separate repositories, illustrating end-to-end applications of the Gemini API.

What's New?

Here are the recent additions and updates to the Gemini API and the Cookbook:

Webhooks: Get real-time notifications for async operations like batch jobs and video generation with the Webhooks quickstart .
Inference tiers: Learn how to use the Priority and Flex tiers in the Inference tiers guide to help you balance speed, cost, and reliability.
🎶 Lyria 3: Convert your ideas into songs with full control over the music structure and more!
🍌 Nano-Banana 2 & Pro: Use Gemini's native image generation capabilities to edit images with high consistency or generate visual stories. Experience Nano-Banana 2 for high speed or Nano-Banana Pro for 4K quality—both now with thinking and search grounding!
File Search: Discover how to ground generations in your own data in a hosted RAG system with the File Search quickstart .
Grounding with Google Maps: Get started using factual geographical data from 📍 Google Maps in your apps! See the Google Maps section of the Grounding Guide .
Veo 3.1: Get started with our video generation model with this Veo guide, including image-to-videos and video extension!
Gemini Robotics-ER 1.5: Learn about this new Gemini model specifically for spatial understanding and reasoning for robotics applications.
Lyria and TTS: Get started with podcast and music generation with the TTS and Lyria RealTime models.
LiveAPI: Get started with the multimodal Live API and unlock new interactivity with Gemini.
Recently Added Guides:
- Grounding : Discover different ways to ground Gemini's answer using different tools, from Google Search to Youtube and URLs and the new Maps grounding tool.
- Batch API : Use Batch API to send large volume of non-time-sensitive requests to the model and get up to 90% discount.
- Logs and datasets : Process and evaluate your collected logs using the Batch API.

1. Quick Starts

The quickstarts section contains step-by-step tutorials to get you started with Gemini and learn about its specific features.

To begin, you'll need:

A Google account.
An API key (create one in Google AI Studio).

We recommend starting with the following:

Authentication : Set up your API key for access.
Get started : Get started with Gemini models and the Gemini API, covering basic prompting and multimodal input.

Then, explore the other quickstarts tutorials to learn about individual features:

Get started with Live API : Get started with the live API with this comprehensive overview of its capabilities
Get started with Veo : Get started with our video generation capabilities
Get started with Imagen and Native image generation : Get started with our image generation capabilities
Grounding : use Google Search for grounded responses
Code execution : Generate and run Python code to solve complex tasks and even output graphs
And many more

2. Examples (Practical Use Cases)

These examples demonstrate how to combine multiple Gemini API features or 3rd-party tools to build more complex applications.

Browser as a tool : Use a web browser for live and internal (intranet) web interactions
Illustrate a book : Use Gemini to create illustration for an open-source book
Animated Story Generation : Create animated videos by combining Gemini's story generation, Imagen, and audio synthesis
Plotting and mapping Live : Mix Live API and Code execution to solve complex tasks live
3D Spatial understanding : Use Gemini 3D spatial abilities to understand 3D scenes
Gradio and live API: Use gradio to deploy your own instance of the Live API
And many many more

3. Demos (End-to-End Applications)

These fully functional, end-to-end applications showcase the power of Gemini in real-world scenarios.

Gemini CLI: Open-source AI agent that brings the power of Gemini directly into your terminal
Gemini API quickstart: Python Flask App running with the Google AI Gemini API, designed to get you started building with Gemini's multi-modal capabilities
Multimodal Live API Web Console: React-based starter app for using the Multimodal Live API over a websocket
Fullstack Langgraph Quickstart: A fullstack application using a React frontend and a LangGraph-powered backend agent
Google AI Studio Starter Applets: A collection of small apps that demonstrate how Gemini can be used to create interactive experiences

Official SDKs

The Gemini API is a REST API. You can call it directly using tools like curl (see REST examples or the great Postman workspace), or use one of our official SDKs:

Get Help

Ask a question on the Google AI Developer Forum.

The Gemini API on Google Cloud Vertex AI

For enterprise developers, the Gemini API is also available on Google Cloud Vertex AI. See this repo for examples.

Contributing

Contributions are welcome! See CONTRIBUTING.md for details.

Thank you for developing with the Gemini API! We're excited to see what you create.

kubernetes/community

Kubernetes community content

Kubernetes Community

Welcome to the Kubernetes community!

This is the starting point for joining and contributing to the Kubernetes community - improving docs, improving code, giving talks etc.

To learn more about the project structure and organization, please refer to Project Governance information.

Communicating

The communication page lists communication channels like chat, issues, mailing lists, conferences, etc.

For more specific topics, try a SIG.

Governance

Kubernetes has the following types of groups that are officially supported:

Committees are named sets of people that are chartered to take on sensitive topics. This group is encouraged to be as open as possible while achieving its mission but, because of the nature of the topics discussed, private communications are allowed. Examples of committees include the steering committee and things like security or code of conduct.
Special Interest Groups (SIGs) are persistent open groups that focus on a part of the project. SIGs must have open and transparent proceedings. Anyone is welcome to participate and contribute provided they follow the Kubernetes Code of Conduct. The purpose of a SIG is to own and develop a set of subprojects.
- Subprojects Each SIG can have a set of subprojects. These are smaller groups that can work independently. Some subprojects will be part of the main Kubernetes deliverables while others will be more speculative and live in the kubernetes-sigs github org.
Working Groups are temporary groups that are formed to address issues that cross SIG boundaries. Working groups do not own any code or other long term artifacts. Working groups can report back and act through involved SIGs.

See the full governance doc for more details on these groups.

A SIG can have its own policy for contribution, described in a README or CONTRIBUTING file in the SIG folder in this repo (e.g. sig-cli/CONTRIBUTING.md), and its own mailing list, slack channel, etc.

If you want to edit details about a SIG (e.g. its weekly meeting time or its leads), please follow these instructions that detail how our docs are auto-generated.

Learn to Build

Links in contributors/devel/README.md lead to many relevant technical topics.

Contribute

A first step to contributing is to pick from the list of kubernetes SIGs. Start attending SIG meetings, join the slack channel and subscribe to the mailing list. SIGs will often have a set of "help wanted" issues that can help new contributors get involved.

The Contributor Guide provides detailed instruction on how to get your ideas and bug fixes seen and accepted, including:

Membership

We encourage all contributors to become members. We aim to grow an active, healthy community of contributors, reviewers, and code owners. Learn more about requirements and responsibilities of membership in our Community Membership page.

ed-donner/agents

Repo for the Complete Agentic AI Engineering Course

Master AI Agentic Engineering - build autonomous AI Agents

6 week journey to code and deploy AI Agents with OpenAI Agents SDK, CrewAI, LangGraph, AutoGen and MCP

If you're looking at this in Cursor, please right click on the filename in the Explorer on the left, and select "Open preview", to view the formatted version.

I couldn't be more excited to welcome you! This is the start of your 6 week adventure into the powerful, astonishing and often surreal world of Agentic AI.

Before you begin

I'm here to help you be most successful! Please do reach out if I can help, either in the platform or by emailing me direct (ed@edwarddonner.com). It's always great to connect with people on LinkedIn to build up the community - you'll find me here:
https://www.linkedin.com/in/eddonner/
And this is new to me, but I'm also trying out X/Twitter at @edwarddonner - if you're on X, please show me how it's done 😂

The not-so-dreaded setup instructions

Perhaps famous last words: but I really, truly hope that I've put together an environment that will be not too horrific to set up!

Windows people, your instructions are here
Mac people, yours are here
Linux people, yours are here

Any problems, please do contact me.

Important notes for CrewAI week (Week 3)

Windows PC users: you will need to have checked the "gotcha #4" at the top of the SETUP-PC instructions -- installing Microsoft Build Tools.
If you don't do this, then CrewAI will fail with an obscure error involving Chroma..

Then, you will need to run this command in a Cursor Terminal in the project root directory in order to run the Crew commands:
uv tool install crewai==0.130.0 --python 3.12
And in case you've used Crew before, it might be worth doing this to make sure you have the latest:
uv tool upgrade crewai==0.130.0 --python 3.12

This command pins Crew to the same version that I use on the course. If you have any problems with Crew, you could try using the latest version instead, by running this command:
uv tool upgrade crewai --python 3.12

At any point, you can see which version of Crew you have installed with this:
uv tool list

Sidenote: a "tool" with uv is a utility that is installed globally by uv. After installing this tool, you can use "crewai" as a command, and it runs the code associated with this tool.

Then please keep in mind for Crew:

There are two ways that you can work on the CrewAI project in week 3. Either review the code for each project while I build it, and then do crewai run to see it in action. Or if you prefer to be more hands-on, then create your own Crew project from scratch to mirror mine; for example, create my_debate to go alongside debate, and write the code alongside me. Either approach works!
Windows users: there's a new issue that was recently introduced by one of Crew's libraries. Until this is fixed, you might get a "unicode" error when you try to run crewai create crew. If that happens, please try running this command in the Terminal first: $env:PYTHONUTF8 = "1"
Gemini users: in addition to a key in your .env file for GOOGLE_API_KEY, you will need an identical key for GEMINI_API_KEY

Super useful resources

The course resources with videos
Many essential guides in the guides section
The troubleshooting notebook
My overall FAQ page with common issues and questions

API costs - please read me!

This course does involve making calls to OpenAI and other frontier models, requiring an API key and a small spend, which we set up in the SETUP instructions. If you'd prefer not to spend on API calls, there are cheaper alternatives like DeepSeek and free alternatives like using Ollama!

Details are here.

Be sure to monitor your API costs to ensure you are totally happy with any spend. For OpenAI, the dashboard is here.

ABOVE ALL ELSE -

Be sure to have fun with the course! You could not have picked a better time to be learning about Agentic AI. I hope you enjoy every single minute! And if you get stuck at any point - contact me.

fchollet/deep-learning-with-python-notebooks

Jupyter notebooks for the code samples of the book "Deep Learning with Python"

Companion notebooks for Deep Learning with Python

This repository contains Jupyter notebooks implementing the code samples found in the book Deep Learning with Python, third edition (2025) by Francois Chollet and Matthew Watson. In addition, you will also find the legacy notebooks for the second edition (2021) and the first edition (2017).

For readability, these notebooks only contain runnable code blocks and section titles, and omit everything else in the book: text paragraphs, figures, and pseudocode. If you want to be able to follow what's going on, I recommend reading the notebooks side by side with your copy of the book.

Running the code

We recommend running these notebooks on Colab, which provides a hosted runtime with all the dependencies you will need. You can also, run these notebooks locally, either by setting up your own Jupyter environment, or using Colab's instructions for running locally.

By default, all notebooks will run on Colab's free tier GPU runtime, which is sufficient to run all code in this book. Chapter 8-18 chapters will benefit from a faster GPU if you have a Colab Pro subscription. You can change your runtime type using Runtime -> Change runtime type in Colab's dropdown menus.

Choosing a backend

The code for third edition is written using Keras 3. As such, it can be run with JAX, TensorFlow or PyTorch as a backend. To set the backend, update the backend in the cell at the top of the colab that looks like this:

import os
os.environ["KERAS_BACKEND"] = "jax"

This must be done only once per session before importing Keras. If you are in the middle running a notebook, you will need to restart the notebook session and rerun all relevant notebook cells. This can be done in using Runtime -> Restart Session in Colab's dropdown menus.

Using Kaggle data

This book uses datasets and model weights provided by Kaggle, an online Machine Learning community and platform. You will need to create a Kaggle login to run Kaggle code in this book; instructions are given in Chapter 8.

For chapters that need Kaggle data, you can login to Kaggle once per session when you hit the notebook cell with kagglehub.login(). Alternately, you can set up your Kaggle login information once as Colab secrets:

Go to https://www.kaggle.com/ and sign in.
Go to https://www.kaggle.com/settings and generate a Kaggle API key.
Open the secrets tab in Colab by clicking the key icon on the left.
Add two secrets, KAGGLE_USERNAME and KAGGLE_KEY with the username and key you just created.

Following this approach you will only need to copy your Kaggle secret key once, though you will need to allow each notebook to access your secrets when running the relevant Kaggle code.

anthropics/prompt-eng-interactive-tutorial

Anthropic's Interactive Prompt Engineering Tutorial

Welcome to Anthropic's Prompt Engineering Interactive Tutorial

Course introduction and goals

This course is intended to provide you with a comprehensive step-by-step understanding of how to engineer optimal prompts within Claude.

After completing this course, you will be able to:

Master the basic structure of a good prompt
Recognize common failure modes and learn the '80/20' techniques to address them
Understand Claude's strengths and weaknesses
Build strong prompts from scratch for common use cases

Course structure and content

This course is structured to allow you many chances to practice writing and troubleshooting prompts yourself. The course is broken up into 9 chapters with accompanying exercises, as well as an appendix of even more advanced methods. It is intended for you to work through the course in chapter order.

Each lesson has an "Example Playground" area at the bottom where you are free to experiment with the examples in the lesson and see for yourself how changing prompts can change Claude's responses. There is also an answer key.

Note: This tutorial uses our smallest, fastest, and cheapest model, Claude 3 Haiku. Anthropic has two other models, Claude 3 Sonnet and Claude 3 Opus, which are more intelligent than Haiku, with Opus being the most intelligent.

This tutorial also exists on Google Sheets using Anthropic's Claude for Sheets extension. We recommend using that version as it is more user friendly.

When you are ready to begin, go to 01_Basic Prompt Structure to proceed.

Each chapter consists of a lesson and a set of exercises.

Beginner

Chapter 1: Basic Prompt Structure
Chapter 2: Being Clear and Direct
Chapter 3: Assigning Roles

Intermediate

Chapter 4: Separating Data from Instructions
Chapter 5: Formatting Output & Speaking for Claude
Chapter 6: Precognition (Thinking Step by Step)
Chapter 7: Using Examples

Advanced

Chapter 8: Avoiding Hallucinations
Chapter 9: Building Complex Prompts (Industry Use Cases)
- Complex Prompts from Scratch - Chatbot
- Complex Prompts for Legal Services
- Exercise: Complex Prompts for Financial Services
- Exercise: Complex Prompts for Coding
- Congratulations & Next Steps
Appendix: Beyond Standard Prompting
- Chaining Prompts
- Tool Use
- Search & Retrieval

UFund-Me/Qbot

[🔥updating ...] AI 自动量化交易机器人(完全本地部署) AI-powered Quantitative Investment Research Platform. 📃 online docs: https://ufund-me.github.io/Qbot ✨ :news: qbot-mini: https://github.com/Charmve/iQuant

👆 右上角点击告诉我，你希望这个项目继续加速开发迭代 ❤️ & ☕️

🤖 Qbot

since Sep 26

Qbot website ^HOT Qbot DeepWiki ^{TRY IT OUT}

AI智能量化投研平台

Qbot is an AI-oriented automated quantitative investment platform, which aims to realize the potential, empower AI technologies in quantitative investment. Qbot supports diverse machine learning modeling paradigms. including supervised learning, market dynamics modeling, and RL.

🤖 Qbot = 智能交易策略 + 回测系统 + 自动化量化交易 (+ 可视化分析工具)
            |           |            |            |
            |           |            |             \_ quantstats (dashboard\online operation)
            |           |             \______________ Qbot - vnpy, pytrader, pyfunds
            |           \____________________________ BackTest - backtrader, easyquant
            \________________________________________ quant.ai - qlib, deep learning strategies

🎺 号外：Qbot微信小程序开发招募 UFund-miniprogram

不建议 fork 项目，本项目会持续更新，只 fork 看不到更新，建议 Star ⭐️ ~

喜欢这个项目吗？请考虑 ❤️赞助本项目，以帮助改进！

Quick Start

Qbot是一个免费的量化投研平台，提供从数据获取、交易策略开发、策略回测、模拟交易到最终实盘交易的全闭环流程。在实盘接入前，有股票、基金评测和策略回测，在模拟环境下做交易验证，近乎实盘的时延、滑点仿真。故，本平台提供GUI前端/客户端（部分功能也支持网页），后端做数据处理、交易调度，实现事件驱动的交易流程。对于策略研究部分，尤其强调机器学习、强化学习的AI策略，结合多因子模型提高收益比。

但本项目可能需要一点点python基础知识，有一点点交易经验，会更容易体会作者的初衷，解决当下产品空缺和广大散户朋友的交易痛点，现在直接免费开源出来！

Qbot 目前仅在 python3.8 pyhont3.9 下测试过，其他版本未测试。

<<< 详细文档 docs/Install_guide.md

cd ~ # $HOME as workspace
git clone https://github.com/UFund-Me/Qbot --depth 1

cd Qbot

pip install -r dev/requirements.txt

export PYTHONPATH=${PYTHONPATH}:$(pwd):$(pwd)/backend/multi-fact/mfm_learner
python main.py  #if run on Mac, please use 'pythonw main.py'

Highlights

1. 模块化分层设计：数据层、策略层、交易引擎抽象设计 - 数据、策略中间表达，方便多种数据接口、交易接口接入，用户自定义策略和因子挖掘 - 支持多种交易对象：股票、基金、期货、虚拟货币

2. 人工智能交易策略、自动化因子挖掘机器学习、强化学习、深度学习策略开发，因子挖掘自动化workflow

3. 多种交易方式：在线回测 + 模拟交易 + 实盘自动化交易以策略研究为目标，提供多种交易方式验证策略和提高收益。

4. 多种提示方式：邮件 + 飞书 + 弹窗 + 微信这是qbot的消息提示模块，多种方式提示交易信息：交易买卖信息、每日交易收益结果、股票每日推荐等。

Strategy pool

通过Qbot 可以积木式完成策略编写、多因子挖掘，实现数据开发、因子开发、组合优化、交易执行的量化交易全流程。

如果说策略是量化的核心，那么因子就是策略的核心。通过Qbot量化投研平台研究员可实现自动化因子挖掘，提取出具备预测能力的单因子，利用历史数据进行回测，如果回测结果显示该因子的预测能力达标，就提交到因子库。然后，对因子库里的因子进行有机组合，以形成预测模型，预测模型是整个量化策略的目标。

以下即为，数据指标单因子或组合因子和通过深度学习、机器学习、强化学习挖掘到的交易因子，然后通过组合优化算法实现趋势交易、风险策略、alpha策略、动量轮动等等交易策略。

策略库源代码路径：qbot/strategy

经典策略

交易对象

选股

择时

风险控制 (组合、仓位管理)

股票/期货/虚拟货币

传统指标（对应下方Qbot支持的指标这里）

因子组合

经典策略

基金

4433法则 ('2022)

同上

智能策略

GBDT

RNN

Reinforcement Learning

🔥 Transformer

🔥 LLM

GBDT

BOOST

Line Regression ('2020)

CNN

RNN

TFT (IJoF'2019)

GATs (NIPS'2017)

SFM (KDD'2017)

Transformer (NeurIPS'2017)

Benchmark and Model zoo

Results and models are available in the model zoo. AI strategies is shown at here, local run python backend/pytrader/strategies/workflow_by_code.py, also provide

👉 点击展开查看具体AI模型benchmark结果

	status	benchmark	framework	DGCNN	RegNetX	addition	arXiv
GBDT	✗	✗	XGBoost	✗	✗	Tianqi Chen, et al. KDD 2016	✗
GBDT	✗	✗	LightGBM	✗	✓	Guolin Ke, et al. NIPS 2017	✗
GBDT	✗	✗	Catboost	✗	✓	Liudmila Prokhorenkova, et al. NIPS 2018	✗
MLP	✓	✓	pytorch	✗	✗	--	✗
LSTM	✓	✓	pytorch	✗	✗	Sepp Hochreiter, et al. Neural computation 1997	✗
LightGBM	✓	✓	pytorch	✗	✗	--	✗
GRU	✓	✗	pytorch	✗	✗	Kyunghyun Cho, et al. 2014	✗
ALSTM	✗	✗	pytorch	✗	✗	Yao Qin, et al. IJCAI 2017	✗
GATs	✗	✓	pytorch	✗	✗	Petar Velickovic, et al. 2017	✗
SFM	✓	✓	pytorch	✗	✗	Liheng Zhang, et al. KDD 2017	✗
TFT	✓	✓	tensorflow	✗	✗	Bryan Lim, et al. International Journal of Forecasting 2019	✗
TabNet	✓	✗	pytorch	✗	✗	Sercan O. Arik, et al. AAAI 2019	✗
DoubleEnsemble	✓	✓	LightGBM	✗	✗	Chuheng Zhang, et al. ICDM 2020	✗
TCTS	✓	✗	pytorch	✗	✗	Xueqing Wu, et al. ICML 2021	✗
Transformer	✓	✗	pytorch	✗	✗	Ashish Vaswani, et al. NeurIPS 2017	✗
Localformer	✓	✗	pytorch	✗	✗	Juyong Jiang, et al.	✗
TRA	✓	✗	pytorch	✗	✗	Hengxu, Dong, et al. KDD 2021	✗
TCN	✓	✗	pytorch	✗	✗	Shaojie Bai, et al. 2018	✗
ADARNN	✓	✗	pytorch	✗	✗	YunTao Du, et al. 2021	✗
ADD	✓	✗	pytorch	✗	✗	Hongshun Tang, et al.2020	✗
IGMTF	✓	✗	pytorch	✗	✗	Wentao Xu, et al.2021	✗
HIST	✓	✗	pytorch	✗	✗	Wentao Xu, et al.2021	✗

^{Note: All the about 300+ models, methods of 40+ papers in quant.ai supported by Model Zoo can be trained or used in this codebase.}

交易指标/因子

包含但不限于alpha-101、alpha-191，以及基于deap实现的因子自动生成算法。

EMA(简单移动均线)
MACD(指数平滑异同平均线)
KDJ(随机指标)
RSRS(阻力支撑相对强度)
RSI(相对强弱指标)
StochRSI(随机相对强弱指数)
BIAS(乖离率)
BOLL(布林线指标)
OBV(能量潮)
SAR(抛物转向)
VOL(成交量)
PSY(心理线)
ARBR(人气和意愿指标)
CR(带状能力线)
BBI(多空指标)
EMV(简易波动指标)
TRIX(三重指数平滑移动平均指标)
DMA(平均线差)
DMI(趋向指标)
CCI(顺势指标)
ROC(变动速率指标, 威廉指标)
ENE(轨道线)  # 轨道线（ENE）由上轨线(UPPER)和下轨线(LOWER)及中轨线(ENE)组成，
            # 轨道线的优势在于其不仅具有趋势轨道的研判分析作用，也可以敏锐的觉察股价运行过程中方向的改变
SKDJ(慢速随机指标)
LWR(慢速威廉指标)  # 趋势判断指标
市盈率
市净率
主力意愿(收费)
买卖差(收费)
散户线(收费)
分时博弈(收费)
买卖力道(收费)
行情趋势(收费)
MTM(动量轮动指标)(收费)
MACD智能参数(收费)
KDJ智能参数(收费)
RSI智能参数(收费)
WR智能参数(收费)
Qbot智能预测(收费)
Qbot买卖强弱指标(收费)

支持的实盘交易接口

证券平台账号开通

低费率开户：股票万0.854免五, ETF万0.4, 可转债万0.4 没有资金门槛。关注公众号可开户

另外提供开通券商量化交易接口，支持python编写实盘交易

支持股票券商

海通客户端(海通网上交易系统独立委托)
华泰客户端(网上交易系统（专业版Ⅱ）)
国金客户端(全能行证券交易终端PC版)
其他券商通用同花顺客户端(需要手动登陆)

开通方式：微信Yida_Zhang2 (注明：开户)

实盘交易接口

欢迎更多交易所、柜台开放交易api

期货

CTP

CTPMini

飞马Femas

艾克朗科（仅组播行情）

易达

期权

CTPOpt

金证期权maOpt

QWIN二开

股票

中泰XTP

中泰XTPXAlgo

华鑫奇点

华锐ATP

宽睿OES

同花顺

东方财富

华泰证券

国泰君安

中汇亿达

恒生UFT

掘金

顶点飞创

华鑫奇点

通达信

虚拟货币/数字货币

欧易OKEX

币安Bianace

火币Huobi

仿真交易接口/平台

API 交易类型操作系统

qbot_pro 股票、期货、基金、虚拟货币 Win、Linux、Mac

掘金仿真股票、基金、期货 Win、Linux、Mac

极星量化期货 Win、Mac

WonderTrader 股票、期货 Win、Linux

TradingView 虚拟货币 Win、Linux、Mac

欧易OKEX、币安 Binance 、火币huobi 虚拟货币 Win、Linux、Mac

加密货币交易所注册推荐码

OKEX 交易所注册推荐码, 手续费返佣 20%

https://www.cnouyi.social/join/57246734

币安交易所注册推荐码, 手续费返佣 10%

https://accounts.binance.com/register?ref=130173909

火币交易所注册推荐码, 手续费返佣 15% (推荐)

https://www.htx.com/invite/zh-cn/1f?invite_code=wr938223

为什么选择币安交易所

交易的手续费看起来很少，但是随着交易次数逐步增多，手续费也是一笔不小的开支。所以我选择了币安，手续费低的大平台交易所

火币手续费 Maker 0.2% Taker 0.2%

币安手续费 Maker 0.1% Taker 0.1% （加上BNB家持手续费低至0.075%）

如果你还没有币安账号：注册页面（通过链接注册，享受交易返现优惠政策）

开源共创、社区共建

首先，感谢自今年5月份开源以来收到广大用户的关注！我们在基础版本中开放了很多传统量化策略、深度学习、强化学习等人工智能策略和多因子库，为此，我们发起《Qbot人工智能量化交易社区共建计划》。采取以下两种方式共建共赢：

内容共建：

在我们免费提供的人工智能交易策略基础上，提高SOTA指标，然后以个人所有权提交Qbot量化交易社区，作为一种策略服务提供给更多人，获取收益；

在我们免费提供的上千个交易因子基础上，应用交易因子完成策略回测、模拟交易，对交易结果好的可作为一种交易策略服务提供给更多人，获取收益；

代码贡献：

参与本代码仓库程序设计与实现，多提交PR合并后可免费加入知识星球；

贡献榜单前10名可获得一年免费使用权，前3名可获得qbot进阶版终身免费使用权；

Qbot 版本说明

版本介绍说明产品与服务适合人群

public（开源版）当前开源仓库 - 开源代码可自行学习，提供整个框架的闭环搭建，实现数据的获取、策略开发、指标分析等功能对量化交易感兴趣的开发者、产品经理

pro(专业版) 专业付费版（年费，更新代码）
- 量化交易智库（研报复现、前沿策略探索、投研资讯））
- qbot_pro 包含基础版本的所有功能，并且实现AI选股、数据获取清洗、策略开发、策略回测、模拟交易、实盘自动化交易全流程闭环
- 封装好的接口示例、系统源码开发示例
- 易于开发的策略模板和因子表达式
- 分层架构设计，数据、策略(回测、实盘交易)中间表达。
- 社群答疑服务
- 遵循《署名-非商业性使用-相同方式共享》开放协议的其他非商业用途的二次开发

- 个人量化交易员、证券交易从业者
- 希望快速学习量化并在股票、基金、虚拟货币实现量化交易的

vip 1对1的会员专项服务（年费，每年更新代码）

- 最新的量化交易系统，包含基础版本和专业版的所有软件功能
- 提供封装好的基金、股票、期货、及现货和合约量化接口（支持Binance现货、合约）
- 多个智能量化策略示例
- 远程技术支持和服务

- 量化交易员
- 希望快速学习量化并在相关市场实现量化交易的
- 定制相关市场接口

Tip

相关软件版本付费及更多信息、答疑解惑，添加微信 Yida_Zhang2

策略原理及源码分析

本项目编写了详细的策略原理说明和平台搭建到使用的详细文档，尤其适合量化小白。欢迎加群交流！

在线文档 | ❓ 常见问题 | Jupyter Notebook

Quantstats Report

Click HERE to more detail.

Some strategy backtest results:

声明：别轻易用于实盘，市场有风险，投资需谨慎。

symbol：华正新材(603186) Starting Portfolio Value: 10000.00 Startdate=datetime.datetime(2010, 1, 1), Enddate=datetime.datetime(2020, 4, 21), # 设置佣金为0.001, 除以100去掉%号 cerebro.broker.setcommission(commission=0.001)

A股回测MACD策略:

👉 点击查看源码

A股回测KDJ策略:

👉 点击查看源码

A股回测 KDJ+MACD 策略:

👉 点击查看源码

TODO

👆 右上角点击告诉我，你希望这个项目继续加速开发迭代 ❤️ & ☕️

把策略回测整合在一个上位机中，包括：选基、选股策略、交易策略，模拟交易，实盘交易

很多策略需要做回测验证；

本项目由前后端支持，有上位机app支持，但目前框架还比较乱，需要做调整；

各种策略需要抽象设计，支持统一调用；

增强数据获取的实时性，每秒数据，降低延迟；

在线文档的完善，目前主要几个部分：新手使用指引、经典策略原理和源码、智能策略原理和源码、常见问题等；

新的feature开发，欢迎在issues交流；

No-code operation

体验下来，dagster是很适合金融数据采集、处理，还有机器学习的场景。当然这里的场景更偏向于“批处理”，“定时任务”的处理与编排。

cd plugins/dagster dagster-daemon run & dagit -h 0.0.0.0 -p 3000

Contributing

We appreciate all contributions to improve Qbot. Please refer to CONTRIBUTING.md for the contributing guideline.

_Charmve

🍮 Community

Github discussions 💬 or issues 💭

微信: Yida_Zhang2

Email: yidazhang1#gmail.com

知乎/小红书：@Charmve | @Charmve

知识星球：AI量化投研实验室（加我微信，邀请）

本星球为VIP付费社群，对于购买Pro版本的用户，可免费加入。拓展人脉，及时获取研报和论文解读与源代码实现，多种投顾服务。

个人微信

Qbot用户微信交流群

^{AI量化交易策略分享、实盘交易教程、实时数据接口}
知识星球（付费）

若二维码因 Github 网络无法打开，请点击二维码直接打开图片。

🎉 本项目刚上线就收到了两次GitHub官方趋势榜Top5、Top1好成绩!

现对于转发本项目到朋友圈或100人以上微信群等，可获得知识星球价值20元的 🎫优惠券一张, 限时10张。

🔥Among the top 10 Quant & Trade repos on GitHub

主要包含两部分：在本项目的基础下，
增加更多策略研究，包含回测源码（请先学会有本项目中的策略库）；

增加实盘接入方式的源代码；

策略交流，AI投研实验室MeetUp线上/线下活动（对于基础薄弱的同学，欢迎进微信群答疑）

最近较为受欢迎的一个福利点：AI选股推荐列表邮件订阅，这有个样例 https://github.com/UFund-Me/Qbot/issues/37

⚠️ Disclaimer

👨‍🏫 重点重点！ 交易策略和自动化工具只是提供便利，并不代表实际交易收益。该项目任何内容不构成任何投资建议。市场有风险，投资需谨慎。

🔥 Stargazers Over Time

Repository Statistics

Daily clones, total forks, and total stars over time. Updated daily at 00:00 UTC.

Sponsors & support

If you like the project, you can become a sponsor at Open Collective or use GitHub Sponsors.

Thank you for supporting Qbot!

LICENSE

署名-非商业性使用-相同方式共享 4.0 国际

♥️ Acknowledgements

Last but not least, we're thankful to these open-source repo for sharing their services for free:

基于 backtrader、vnpy、qlib、tushare、easyquant、fund-strategies、investool 等开源项目，感谢开发者。

感谢大家的支持与喜欢！

Code with ❤️ & ☕️ @Charmve 2022-2023

API	交易类型	操作系统
qbot_pro	股票、期货、基金、虚拟货币	Win、Linux、Mac
掘金仿真	股票、基金、期货	Win、Linux、Mac
极星量化	期货	Win、Mac
WonderTrader	股票、期货	Win、Linux
TradingView	虚拟货币	Win、Linux、Mac
欧易OKEX、币安 Binance 、火币huobi	虚拟货币	Win、Linux、Mac

版本介绍	说明	产品与服务	适合人群
public（开源版）	当前开源仓库	- 开源代码可自行学习，提供整个框架的闭环搭建，实现数据的获取、策略开发、指标分析等功能	对量化交易感兴趣的开发者、产品经理
pro(专业版)	专业付费版（年费，更新代码）	- 量化交易智库（研报复现、前沿策略探索、投研资讯）） - qbot_pro 包含基础版本的所有功能，并且实现AI选股、数据获取清洗、策略开发、策略回测、模拟交易、实盘自动化交易全流程闭环 - 封装好的接口示例、系统源码开发示例 - 易于开发的策略模板和因子表达式 - 分层架构设计，数据、策略(回测、实盘交易)中间表达。 - 社群答疑服务 - 遵循《署名-非商业性使用-相同方式共享》开放协议的其他非商业用途的二次开发	- 个人量化交易员、证券交易从业者 - 希望快速学习量化并在股票、基金、虚拟货币实现量化交易的
vip	1对1的会员专项服务（年费，每年更新代码）	- 最新的量化交易系统，包含基础版本和专业版的所有软件功能 - 提供封装好的基金、股票、期货、及现货和合约量化接口（支持Binance现货、合约） - 多个智能量化策略示例 - 远程技术支持和服务	- 量化交易员 - 希望快速学习量化并在相关市场实现量化交易的 - 定制相关市场接口

NirDiamant/GenAI_Agents

50+ tutorials and implementations for Generative AI Agent techniques, from basic conversational bots to complex multi-agent systems.

🌟 Support This Project: Your sponsorship fuels innovation in GenAI agent development. Become a sponsor to help maintain and expand this valuable resource!

GenAI Agents: Comprehensive Repository for Development and Implementation 🚀

Welcome to one of the most extensive and dynamic collections of Generative AI (GenAI) agent tutorials and implementations available today. This repository serves as a comprehensive resource for learning, building, and sharing GenAI agents, ranging from simple conversational bots to complex, multi-agent systems.

📖 From the Same Author

RAG Made Simple — #1 Best Seller on Amazon in Generative AI. 22 RAG techniques with intuition, comparisons, and illustrations. Free with Kindle Unlimited or $0.99 launch price (goes up soon).

👉 Get the book on Amazon

🏆 Sponsors

Recently added: HR AI Assistant, Art Tourguide with LightRAG, Contextual Quoting System, ML/DS Assistant, Gutenberg Sage | 52 tutorials and growing

📫 Stay Updated!

🚀
Cutting-edge
Updates

💡
Expert
Insights

🎯
Top 0.1%
Content

Join over 50,000 AI enthusiasts getting unique cutting-edge insights and free tutorials! Plus, subscribers get exclusive early access and special 33% discounts to my book and the upcoming RAG Techniques course!

Introduction

Generative AI agents are at the forefront of artificial intelligence, revolutionizing the way we interact with and leverage AI technologies. This repository is designed to guide you through the development journey, from basic agent implementations to advanced, cutting-edge systems.

📚 Learn to Build Your First AI Agent

Your First AI Agent: Simpler Than You Think

This detailed blog post complements the repository by providing a complete A-Z walkthrough with in-depth explanations of core concepts, step-by-step implementation, and the theory behind AI agents. It's designed to be incredibly simple to follow while covering everything you need to know to build your first working agent from scratch.

💡 Plus: Subscribe to the newsletter for exclusive early access to tutorials and special discounts on upcoming courses and books!

Our goal is to provide a valuable resource for everyone - from beginners taking their first steps in AI to seasoned practitioners pushing the boundaries of what's possible. By offering a range of examples from foundational to complex, we aim to facilitate learning, experimentation, and innovation in the rapidly evolving field of GenAI agents.

Furthermore, this repository serves as a platform for showcasing innovative agent creations. Whether you've developed a novel agent architecture or found an innovative application for existing techniques, we encourage you to share your work with the community.

Related Projects

🚀 Level up with my Agents Towards Production repository. It delivers horizontal, code-first tutorials that cover every tool and step in the lifecycle of building production-grade GenAI agents, guiding you from spark to scale with proven patterns and reusable blueprints for real-world launches, making it the smartest place to start if you're serious about shipping agents to production.

📚 Dive into my comprehensive guide on RAG techniques to learn about integrating external knowledge into AI systems, enhancing their capabilities with up-to-date and relevant information retrieval.

🖋️ Explore my Prompt Engineering Techniques guide for an extensive collection of prompting strategies, from fundamental concepts to advanced methods, improving your ability to communicate effectively with AI language models.

A Community-Driven Knowledge Hub

This repository grows stronger with your contributions! Join our vibrant communities - the central hubs for shaping and advancing this project together 🤝

Educational AI Subreddit

GenAI Agents Discord Community

Whether you're a novice eager to learn or an expert ready to share your knowledge, your insights can shape the future of GenAI agents. Join us to propose ideas, get feedback, and collaborate on innovative implementations. For contribution guidelines, please refer to our CONTRIBUTING.md file. Let's advance GenAI agent technology together!

🔗 For discussions on GenAI, agents, or to explore knowledge-sharing opportunities, feel free to connect on LinkedIn.

Key Features

🎓 Learn to build GenAI agents from beginner to advanced levels
🧠 Explore a wide range of agent architectures and applications
📚 Step-by-step tutorials and comprehensive documentation
🛠️ Practical, ready-to-use agent implementations
🌟 Regular updates with the latest advancements in GenAI
🤝 Share your own agent creations with the community

GenAI Agent Implementations

Below is a comprehensive overview of our GenAI agent implementations, organized by category and functionality. Each implementation is designed to showcase different aspects of AI agent development, from basic conversational agents to complex multi-agent systems.

#	Category	Agent Name	Framework	Key Features
1	🌱 Beginner	Simple Conversational Agent	LangChain/PydanticAI	Context-aware conversations, history management
2	🌱 Beginner	Simple Question Answering	LangChain	Query understanding, concise answers
3	🌱 Beginner	Simple Data Analysis	LangChain/PydanticAI	Dataset interpretation, natural language queries
4	🔧 Framework	Introduction to LangGraph	LangGraph	Modular AI workflows, state management
5	🔧 Framework	Model Context Protocol (MCP)	MCP	AI-external resource integration
6	🎓 Educational	ATLAS: Academic Task System	LangGraph	Multi-agent academic planning, note-taking
7	🎓 Educational	Scientific Paper Agent	LangGraph	Literature review automation
8	🎓 Educational	Chiron - Feynman Learning	LangGraph	Adaptive learning, checkpoint system
9	💼 Business	Customer Support Agent	LangGraph	Query categorization, sentiment analysis
10	💼 Business	Essay Grading Agent	LangGraph	Automated grading, multiple criteria
11	💼 Business	Travel Planning Agent	LangGraph	Personalized itineraries
12	💼 Business	GenAI Career Assistant	LangGraph	Career guidance, learning paths
13	💼 Business	Project Manager Assistant	LangGraph	Task generation, risk assessment
14	💼 Business	Contract Analysis Assistant	LangGraph	Clause analysis, compliance checking
15	💼 Business	E2E Testing Agent	LangGraph	Test automation, browser control
16	🎨 Creative	GIF Animation Generator	LangGraph	Text-to-animation pipeline
17	🎨 Creative	TTS Poem Generator	LangGraph	Text classification, speech synthesis
18	🎨 Creative	Music Compositor	LangGraph	AI music composition
19	🎨 Creative	Content Intelligence	LangGraph	Multi-platform content generation
20	🎨 Creative	Business Meme Generator	LangGraph	Brand-aligned meme creation
21	🎨 Creative	Murder Mystery Game	LangGraph	Procedural story generation
22	📊 Analysis	Memory-Enhanced Conversational	LangChain	Short/long-term memory integration
23	📊 Analysis	Multi-Agent Collaboration	LangChain	Historical research, data analysis
24	📊 Analysis	Self-Improving Agent	LangChain	Learning from interactions
25	📊 Analysis	Task-Oriented Agent	LangChain	Text summarization, translation
26	📊 Analysis	Internet Search Agent	LangChain	Web research, summarization
27	📊 Analysis	Research Team - Autogen	AutoGen	Multi-agent research collaboration
28	📊 Analysis	Sales Call Analyzer	LangGraph	Audio transcription, NLP analysis
29	📊 Analysis	Weather Emergency System	LangGraph	Real-time data processing
30	📊 Analysis	Self-Healing Codebase	LangGraph	Error detection, automated fixes
31	📊 Analysis	DataScribe	LangGraph	Database exploration, query planning
32	📊 Analysis	Memory-Enhanced Email	LangGraph	Email triage, response generation
33	📰 News	News TL;DR	LangGraph	News summarization, API integration
34	📰 News	AInsight	LangGraph	AI/ML news aggregation
35	📰 News	Journalism Assistant	LangGraph	Fact-checking, bias detection
36	📰 News	Blog Writer	OpenAI Swarm	Collaborative content creation
37	📰 News	Podcast Generator	LangGraph	Content search, audio generation
38	🛍️ Shopping	ShopGenie	LangGraph	Product comparison, recommendations
39	🛍️ Shopping	Car Buyer Agent	LangGraph	Web scraping, decision support
40	🎯 Task Management	Taskifier	LangGraph	Work style analysis, task breakdown
41	🎯 Task Management	Grocery Management	CrewAI	Inventory tracking, recipe suggestions
42	🔍 QA	LangGraph Inspector	LangGraph	System testing, vulnerability detection
43	🔍 QA	EU Green Deal Bot	LangGraph	Regulatory compliance, FAQ system
44	🔍 QA	Systematic Review	LangGraph	Academic paper processing, draft generation
45	🌟 Advanced	Controllable RAG Agent	Custom	Complex question answering, deterministic graph

Explore our extensive list of GenAI agent implementations, sorted by categories:

🌱 Beginner-Friendly Agents

Simple Conversational Agent
- LangChain
- PydanticAI
Overview 🔎

A context-aware conversational AI maintains information across interactions, enabling more natural dialogues.

Implementation 🛠️

Integrates a language model, prompt template, and history manager to generate contextual responses and track conversation sessions.
Simple Question Answering Agent

Overview 🔎

Answering (QA) agent using LangChain and OpenAI's language model understands user queries and provides relevant, concise answers.

Implementation 🛠️

Combines OpenAI's GPT model, a prompt template, and an LLMChain to process user questions and generate AI-driven responses in a streamlined manner.
Simple Data Analysis Agent
- LangChain
- PydanticAI
Overview 🔎

An AI-powered data analysis agent interprets and answers questions about datasets using natural language, combining language models with data manipulation tools for intuitive data exploration.

Implementation 🛠️

Integrates a language model, data manipulation framework, and agent framework to process natural language queries and perform data analysis on a synthetic dataset, enabling accessible insights for non-technical users.

🔧 Framework Tutorial

Introduction to LangGraph: Building Modular AI Workflows

Overview 🔎

This tutorial introduces LangGraph, a powerful framework for creating modular, graph-based AI workflows. Learn how to leverage LangGraph to build more complex and flexible AI agents that can handle multi-step processes efficiently.

Implementation 🛠️

Step-by-step guide on using LangGraph to create a StateGraph workflow. The tutorial covers key concepts such as state management, node creation, and graph compilation. It demonstrates these principles by constructing a simple text analysis pipeline, serving as a foundation for more advanced agent architectures.

Additional Resources 📚
- Blog Post
Model Context Protocol (MCP): Seamless Integration of AI and External Resources

Overview 🔎

This tutorial introduces the Model Context Protocol (MCP), an open standard for connecting AI models with external data sources and tools. Learn how MCP serves as a universal bridge between GenAI agents and the wider digital ecosystem, enabling more capable and context-aware AI applications.

Implementation 🛠️

Provides a hands-on guide to implementing MCP servers and clients, demonstrating how to connect language models with external tools and data sources. The tutorial covers server setup, tool definition, and integration with AI clients, with practical examples of building useful agent capabilities through the protocol.

Additional Resources 📚
- Blog Post
- Official MCP Documentation
- MCP GitHub Repository

🎓 Educational and Research Agents

ATLAS: Academic Task and Learning Agent System

Overview 🔎

ATLAS demonstrates how to build an intelligent multi-agent system that transforms academic support through AI-powered assistance. The system leverages LangGraph's workflow framework to coordinate multiple specialized agents that provide personalized academic planning, note-taking, and advisory support.

Implementation 🛠️

Implements a state-managed multi-agent architecture using four specialized agents (Coordinator, Planner, Notewriter, and Advisor) working in concert through LangGraph's workflow framework. The system features sophisticated workflows for profile analysis and academic support, with continuous adaptation based on student performance and feedback.

Additional Resources 📚
- YouTube Explanation
- Blog Post
Scientific Paper Agent - Literature Review

Overview 🔎

An intelligent research assistant that helps users navigate, understand, and analyze scientific literature through an orchestrated workflow. The system combines academic APIs with sophisticated paper processing techniques to automate literature review tasks, enabling researchers to efficiently extract insights from academic papers while maintaining research rigor and quality control.

Implementation 🛠️

Leverages LangGraph to create a five-node workflow system including decision making, planning, tool execution, and quality validation nodes. The system integrates the CORE API for paper access, PDFplumber for document processing, and advanced language models for analysis. Key features include a retry mechanism for robust paper downloads, structured data handling through Pydantic models, and quality-focused improvement cycles with human-in-the-loop validation options.

Additional Resources 📚
- YouTube Explanation
- Blog Post
Chiron - A Feynman-Enhanced Learning Agent

Overview 🔎

An adaptive learning agent that guides users through educational content using a structured checkpoint system and Feynman-style teaching. The system processes learning materials (either user-provided or web-retrieved), verifies understanding through interactive checkpoints, and provides simplified explanations when needed, creating a personalized learning experience that mimics one-on-one tutoring.

Implementation 🛠️

Uses LangGraph to orchestrate a learning workflow that includes checkpoint definition, context building, understanding verification, and Feynman teaching nodes. The system integrates web search for dynamic content retrieval, employs semantic chunking for context processing, and manages embeddings for relevant information retrieval. Key features include a 70% understanding threshold for progression, interactive human-in-the-loop validation, and structured output through Pydantic models for consistent data handling.

Additional Resources 📚
- YouTube Explanation

💼 Business and Professional Agents

Customer Support Agent (LangGraph)

Overview 🔎

An intelligent customer support agent using LangGraph categorizes queries, analyzes sentiment, and provides appropriate responses or escalates issues.

Implementation 🛠️

Utilizes LangGraph to create a workflow combining state management, query categorization, sentiment analysis, and response generation.
Essay Grading Agent (LangGraph)

Overview 🔎

An automated essay grading system using LangGraph and an LLM model evaluates essays based on relevance, grammar, structure, and depth of analysis.

Implementation 🛠️

Utilizes a state graph to define the grading workflow, incorporating separate grading functions for each criterion.
Travel Planning Agent (LangGraph)

Overview 🔎

A Travel Planner using LangGraph demonstrates how to build a stateful, multi-step conversational AI application that collects user input and generates personalized travel itineraries.

Implementation 🛠️

Utilizes StateGraph to define the application flow, incorporates custom PlannerState for process management.
GenAI Career Assistant Agent

Overview 🔎

The GenAI Career Assistant demonstrates how to create a multi-agent system that provides personalized guidance for careers in Generative AI. Using LangGraph and Gemini LLM, the system delivers customized learning paths, resume assistance, interview preparation, and job search support.

Implementation 🛠️

Leverages a multi-agent architecture using LangGraph to coordinate specialized agents (Learning, Resume, Interview, Job Search) through TypedDict-based state management. The system employs sophisticated query categorization and routing while integrating with external tools like DuckDuckGo for job searches and dynamic content generation.

Additional Resources 📚
- YouTube Explanation
Project Manager Assistant Agent

Overview 🔎

An AI agent designed to assist in project management tasks by automating the process of creating actionable tasks from project descriptions, identifying dependencies, scheduling work, and assigning tasks to team members based on expertise. The system includes risk assessment and self-reflection capabilities to optimize project plans through multiple iterations, aiming to minimize overall project risk.

Implementation 🛠️

Leverages LangGraph to orchestrate a workflow of specialized nodes including task generation, dependency mapping, scheduling, allocation, and risk assessment. Each node uses GPT-4o-mini for structured outputs following Pydantic models. The system implements a feedback loop for self-improvement, where risk scores trigger reflection cycles that generate insights to optimize the project plan. Visualization tools display Gantt charts of the generated schedules across iterations.

Additional Resources 📚
- YouTube Explanation
Contract Analysis Assistant (ClauseAI)

Overview 🔎

ClauseAI demonstrates how to build an AI-powered contract analysis system using a multi-agent approach. The system employs specialized AI agents for different aspects of contract review, from clause analysis to compliance checking, and leverages LangGraph for workflow orchestration and Pinecone for efficient clause retrieval and comparison.

Implementation 🛠️

Implements a sophisticated state-based workflow using LangGraph to coordinate multiple AI agents through contract analysis stages. The system features Pydantic models for data validation, vector storage with Pinecone for clause comparison, and LLM-based analysis for generating comprehensive contract reports. The implementation includes parallel processing capabilities and customizable report generation based on user requirements.

Additional Resources 📚
- YouTube Explanation
E2E Testing Agent

Overview 🔎

The E2E Testing Agent demonstrates how to build an AI-powered system that converts natural language test instructions into executable end-to-end web tests. Using LangGraph for workflow orchestration and Playwright for browser automation, the system enables users to specify test cases in plain English while handling the complexity of test generation and execution.

Implementation 🛠️

Implements a structured workflow using LangGraph to coordinate test generation, validation, and execution. The system features TypedDict state management, integration with Playwright for browser automation, and LLM-based code generation for converting natural language instructions into executable test scripts. The implementation includes DOM state analysis, error handling, and comprehensive test reporting.

Additional Resources 📚
- YouTube Explanation

🎨 Creative and Content Generation Agents

GIF Animation Generator Agent (LangGraph)

Overview 🔎

A GIF animation generator that integrates LangGraph for workflow management, GPT-4 for text generation, and DALL-E for image creation, producing custom animations from user prompts.

Implementation 🛠️

Utilizes LangGraph to orchestrate a workflow that generates character descriptions, plots, and image prompts using GPT-4, creates images with DALL-E 3, and assembles them into GIFs using PIL. Employs asynchronous programming for efficient parallel processing.
TTS Poem Generator Agent (LangGraph)

Overview 🔎

An advanced text-to-speech (TTS) agent using LangGraph and OpenAI's APIs classifies input text, processes it based on content type, and generates corresponding speech output.

Implementation 🛠️

Utilizes LangGraph to orchestrate a workflow that classifies input text using GPT models, applies content-specific processing, and converts the processed text to speech using OpenAI's TTS API. The system adapts its output based on the identified content type (general, poem, news, or joke).
Music Compositor Agent (LangGraph)

Overview 🔎

An AI Music Compositor using LangGraph and OpenAI's language models generates custom musical compositions based on user input. The system processes the input through specialized components, each contributing to the final musical piece, which is then converted to a playable MIDI file.

Implementation 🛠️

LangGraph orchestrates a workflow that transforms user input into a musical composition, using ChatOpenAI (GPT-4) to generate melody, harmony, and rhythm, which are then style-adapted. The final AI-generated composition is converted to a MIDI file using music21 and can be played back using pygame.
Content Intelligence: Multi-Platform Content Generation Agent

Overview 🔎

Content Intelligence demonstrates how to build an advanced content generation system that transforms input text into platform-optimized content across multiple social media channels. The system employs LangGraph for workflow orchestration to analyze content, conduct research, and generate tailored content while maintaining brand consistency across different platforms.

Implementation 🛠️

Implements a sophisticated workflow using LangGraph to coordinate multiple specialized nodes (Summary, Research, Platform-Specific) through the content generation process. The system features TypedDict and Pydantic models for state management, integration with Tavily Search for research enhancement, and platform-specific content generation using GPT-4. The implementation includes parallel processing for multiple platforms and customizable content templates.

Additional Resources 📚
- YouTube Explanation
Business Meme Generator Using LangGraph and Memegen.link

Overview 🔎

The Business Meme Generator demonstrates how to create an AI-powered system that generates contextually relevant memes based on company website analysis. Using LangGraph for workflow orchestration, the system combines Groq's Llama model for text analysis and the Memegen.link API to automatically produce brand-aligned memes for digital marketing.

Implementation 🛠️

Implements a state-managed workflow using LangGraph to coordinate website content analysis, meme concept generation, and image creation. The system features Pydantic models for data validation, asynchronous processing with aiohttp, and integration with external APIs (Groq, Memegen.link) to create a complete meme generation pipeline with customizable templates.

Additional Resources 📚
- YouTube Explanation
Murder Mystery Game with LLM Agents

Overview 🔎

A text-based detective game that utilizes autonomous LLM agents as interactive characters in a procedurally generated murder mystery. Drawing inspiration from the UNBOUNDED paper, the system creates unique scenarios each time, with players taking on the role of Sherlock Holmes to solve the case through character interviews and deductive reasoning.

Implementation 🛠️

Leverages two LangGraph workflows - a main game loop for story/character generation and game progression, and a conversation sub-graph for character interactions. The system uses a combination of LLM-powered narrative generation, character AI, and structured game mechanics to create an immersive investigative experience with replayable storylines.

Additional Resources 📚
- YouTube Explanation

📊 Analysis and Information Processing Agents

Memory-Enhanced Conversational Agent

Overview 🔎

A memory-enhanced conversational AI agent incorporates short-term and long-term memory systems to maintain context within conversations and across multiple sessions, improving interaction quality and personalization.

Implementation 🛠️

Integrates a language model with separate short-term and long-term memory stores, utilizes a prompt template incorporating both memory types, and employs a memory manager for storage and retrieval. The system includes an interaction loop that updates and utilizes memories for each response.
Multi-Agent Collaboration System

Overview 🔎

A multi-agent collaboration system combining historical research with data analysis, leveraging large language models to simulate specialized agents working together to answer complex historical questions.

Implementation 🛠️

Utilizes a base Agent class to create specialized HistoryResearchAgent and DataAnalysisAgent, orchestrated by a HistoryDataCollaborationSystem. The system follows a five-step process: historical context provision, data needs identification, historical data provision, data analysis, and final synthesis.
Self-Improving Agent

Overview 🔎

A Self-Improving Agent using LangChain engages in conversations, learns from interactions, and continuously improves its performance over time through reflection and adaptation.

Implementation 🛠️

Integrates a language model with chat history management, response generation, and a reflection mechanism. The system employs a learning system that incorporates insights from reflection to enhance future performance, creating a continuous improvement loop.
Task-Oriented Agent

Overview 🔎

A language model application using LangChain that summarizes text and translates the summary to Spanish, combining custom functions, structured tools, and an agent for efficient text processing.

Implementation 🛠️

Utilizes custom functions for summarization and translation, wrapped as structured tools. Employs a prompt template to guide the agent, which orchestrates the use of tools. An agent executor manages the process, taking input text and producing both an English summary and its Spanish translation.
Internet Search and Summarize Agent

Overview 🔎

An intelligent web research assistant that combines web search capabilities with AI-powered summarization, automating the process of gathering information from the internet and distilling it into concise, relevant summaries.

Implementation 🛠️

Integrates a web search module using DuckDuckGo's API, a result parser, and a text summarization engine leveraging OpenAI's language models. The system performs site-specific or general searches, extracts relevant content, generates concise summaries, and compiles attributed results for efficient information retrieval and synthesis.
Multi agent research team - Autogen

Overview 🔎

This technique explores a multi-agent system for collaborative research using the AutoGen library. It employs agents to solve tasks collaboratively, focusing on efficient execution and quality assurance. The system enhances research by distributing tasks among specialized agents.

Implementation 🛠️

Agents are configured with specific roles using the GPT-4 model, including admin, developer, planner, executor, and quality assurance. Interaction management ensures orderly communication with defined transitions. Task execution involves collaborative planning, coding, execution, and quality checking, demonstrating a scalable framework for various domains.

Additional Resources 📚
- comprehensive solution with UI
- Blogpost
Sales Call Analyzer

Overview 🔎

An intelligent system that automates the analysis of sales call recordings by combining audio transcription with advanced natural language processing. The analyzer transcribes audio using OpenAI's Whisper, processes the text using NLP techniques, and generates comprehensive reports including sentiment analysis, key phrases, pain points, and actionable recommendations to improve sales performance.

Implementation 🛠️

Utilizes multiple components in a structured workflow: OpenAI Whisper for audio transcription, CrewAI for task automation and agent management, and LangChain for orchestrating the analysis pipeline. The system processes audio through a series of steps from transcription to detailed analysis, leveraging custom agents and tasks to generate structured JSON reports containing insights about customer sentiment, sales opportunities, and recommended improvements.

Additional Resources 📚
- YouTube Explanation
Weather Emergency & Response System

Overview 🔎

A comprehensive system demonstrating two agent graph implementations for weather emergency response: a real-time graph processing live weather data, and a hybrid graph combining real and simulated data for testing high-severity scenarios. The system handles complete workflow from data gathering through emergency plan generation, with automated notifications and human verification steps.

Implementation 🛠️

Utilizes LangGraph for orchestrating complex workflows with state management, integrating OpenWeatherMap API for real-time data, and Gemini for analysis and response generation. The system incorporates email notifications, social media monitoring simulation, and severity-based routing with configurable human verification for low/medium severity events.

Additional Resources 📚
- YouTube Explanation
Self-Healing Codebase System

Overview 🔎

An intelligent system that automatically detects, diagnoses, and fixes runtime code errors using LangGraph workflow orchestration and ChromaDB vector storage. The system maintains a memory of encountered bugs and their fixes through vector embeddings, enabling pattern recognition for similar errors across the codebase.

Implementation 🛠️

Utilizes a state-based graph workflow that processes function definitions and runtime arguments through specialized nodes for error detection, code analysis, and fix generation. Incorporates ChromaDB for vector-based storage of bug patterns and fixes, with automated search and retrieval capabilities for similar error patterns, while maintaining code execution safety through structured validation steps.

Additional Resources 📚
- YouTube Explanation
DataScribe: AI-Powered Schema Explorer

Overview 🔎

An intelligent agent system that enables intuitive exploration and querying of relational databases through natural language interactions. The system utilizes a fleet of specialized agents, coordinated by a stateful Supervisor, to handle schema discovery, query planning, and data analysis tasks while maintaining contextual understanding through vector-based relationship graphs.

Implementation 🛠️

Leverages LangGraph for orchestrating a multi-agent workflow including discovery, inference, and planning agents, with NetworkX for relationship graph visualization and management. The system incorporates dynamic state management through TypedDict classes, maintains database context between sessions using a db_graph attribute, and includes safety measures to prevent unauthorized database modifications.
Memory-Enhanced Email Agent (LangGraph & LangMem)

Overview 🔎

An intelligent email assistant that combines three types of memory (semantic, episodic, and procedural) to create a system that improves over time. The agent can triage incoming emails, draft contextually appropriate responses using stored knowledge, and enhance its performance based on user feedback.

Implementation 🛠️

Leverages LangGraph for workflow orchestration and LangMem for sophisticated memory management across multiple memory types. The system implements a triage workflow with memory-enhanced decision making, specialized tools for email composition and calendar management, and a self-improvement mechanism that updates its own prompts based on feedback and past performance.

Additional Resources 📚
- **Blog Post

📰 News and Information Agents

News TL;DR using LangGraph

Overview 🔎

A news summarization system that generates concise TL;DR summaries of current events based on user queries. The system leverages large language models for decision making and summarization while integrating with news APIs to access up-to-date content, allowing users to quickly catch up on topics of interest through generated bullet-point summaries.

Implementation 🛠️

Utilizes LangGraph to orchestrate a workflow combining multiple components: GPT-4o-mini for generating search terms and article summaries, NewsAPI for retrieving article metadata, BeautifulSoup for web scraping article content, and Asyncio for concurrent processing. The system follows a structured pipeline from query processing through article selection and summarization, managing the flow between components to produce relevant TL;DRs of current news articles.

Additional Resources 📚
- YouTube Explanation
- Blog Post
AInsight: AI/ML Weekly News Reporter

Overview 🔎

AInsight demonstrates how to build an intelligent news aggregation and summarization system using a multi-agent architecture. The system employs three specialized agents (NewsSearcher, Summarizer, Publisher) to automatically collect, process and summarize AI/ML news for general audiences through LangGraph-based workflow orchestration.

Implementation 🛠️

Implements a state-managed multi-agent system using LangGraph to coordinate the news collection (Tavily API), technical content summarization (GPT-4), and report generation processes. The system features modular architecture with TypedDict-based state management, external API integration, and markdown report generation with customizable templates.

Additional Resources 📚
- YouTube Explanation
Journalism-Focused AI Assistant

Overview 🔎

A specialized AI assistant that helps journalists tackle modern journalistic challenges like misinformation, bias, and information overload. The system integrates fact-checking, tone analysis, summarization, and grammar review tools to enhance the accuracy and efficiency of journalistic work while maintaining ethical reporting standards.

Implementation 🛠️

Leverages LangGraph to orchestrate a workflow of specialized components including language models for analysis and generation, web search integration via DuckDuckGo's API, document parsing tools like PyMuPDFLoader and WebBaseLoader, text splitting with RecursiveCharacterTextSplitter, and structured JSON outputs. Each component works together through a unified workflow to analyze content, verify facts, detect bias, extract quotes, and generate comprehensive reports.
Blog Writer (Open AI Swarm)

Overview 🔎

A multi-agent system for collaborative blog post creation using OpenAI's Swarm package. It leverages specialized agents to perform research, planning, writing, and editing tasks efficiently.

Implementation 🛠️

Utilizes OpenAI's Swarm Package to manage agent interactions. Includes an admin, researcher, planner, writer, and editor, each with specific roles. The system follows a structured workflow: topic setting, outlining, research, drafting, and editing. This approach enhances content creation through task distribution, specialization, and collaborative problem-solving.

Additional Resources 📚
- Swarm Repo
Podcast Internet Search and Generate Agent 🎙️

Overview 🔎

A two step agent that first searches the internet for a given topic and then generates a podcast on the topic found. The search step uses a search agent and search function to find the most relevant information. The second step uses a podcast generation agent and generation function to create a podcast on the topic found.

Implementation 🛠️

Utilizes LangGraph to orchestrate a two-step workflow. The first step involves a search agent and function to gather information from the internet. The second step uses a podcast generation agent and function to create a podcast based on the gathered information.

🛍️ Shopping and Product Analysis Agents

ShopGenie - Redefining Online Shopping Customer Experience

Overview 🔎

An AI-powered shopping assistant that helps customers make informed purchasing decisions even without domain expertise. The system analyzes product information from multiple sources, compares specifications and reviews, identifies the best option based on user needs, and delivers recommendations through email with supporting video reviews, creating a comprehensive shopping experience.

Implementation 🛠️

Uses LangGraph to orchestrate a workflow combining Tavily for web search, Llama-3.1-70B for structured data analysis and product comparison, and YouTube API for review video retrieval. The system processes search results through multiple nodes including schema mapping, product comparison, review identification, and email generation. Key features include structured Pydantic models for consistent data handling, retry mechanisms for robust API interactions, and email delivery through SMTP for sharing recommendations.

Additional Resources 📚
- YouTube Explanation
Car Buyer AI Agent

Overview 🔎

The Smart Product Buyer AI Agent demonstrates how to build an intelligent system that assists users in making informed purchasing decisions. Using LangGraph and LLM-based intelligence, the system processes user requirements, scrapes product listings from websites like AutoTrader, and provides detailed analysis and recommendations for car purchases.

Implementation 🛠️

Implements a state-based workflow using LangGraph to coordinate user interaction, web scraping, and decision support. The system features TypedDict state management, async web scraping with Playwright, and integrates with external APIs for comprehensive product analysis. The implementation includes a Gradio interface for real-time chat interaction and modular scraper architecture for easy extension to additional product categories.

Additional Resources 📚
- YouTube Explanation

🎯 Task Management and Productivity Agents

Taskifier - Intelligent Task Allocation & Management

Overview 🔎

An intelligent task management system that analyzes user work styles and creates personalized task breakdown strategies, born from the observation that procrastination often stems from task ambiguity among students and early-career professionals. The system evaluates historical work patterns, gathers relevant task information through web search, and generates customized step-by-step approaches to optimize productivity and reduce workflow paralysis.

Implementation 🛠️

Leverages LangGraph for orchestrating a multi-step workflow including work style analysis, information gathering via Tavily API, and customized plan generation. The system maintains state through the process, integrating historical work pattern data with fresh task research to output detailed, personalized task execution plans aligned with the user's natural working style.

Additional Resources 📚
- YouTube Explanation
Grocery Management Agents System

Overview 🔎

A multi-agent system built with CrewAI that automates grocery management tasks including receipt interpretation, expiration date tracking, inventory management, and recipe recommendations. The system uses specialized agents to extract data from receipts, estimate product shelf life, track consumption, and suggest recipes to minimize food waste.

Implementation 🛠️

Implements four specialized agents using CrewAI - a Receipt Interpreter that extracts item details from receipts, an Expiration Date Estimator that determines shelf life using online sources, a Grocery Tracker that maintains inventory based on consumption, and a Recipe Recommender that suggests meals using available ingredients. Each agent has specific tools and tasks orchestrated through a crew workflow.

Additional Resources 📚
- YouTube Explanation

🔍 Quality Assurance and Testing Agents

LangGraph-Based Systems Inspector

Overview 🔎

A comprehensive testing and validation tool for LangGraph-based applications that automatically analyzes system architecture, generates test cases, and identifies potential vulnerabilities through multi-agent inspection. The inspector employs specialized AI testers to evaluate different aspects of the system, from basic functionality to security concerns and edge cases.

Implementation 🛠️

Integrates LangGraph for workflow orchestration, multiple LLM-powered testing agents, and a structured evaluation pipeline that includes static analysis, test case generation, and results verification. The system uses Pydantic for data validation, NetworkX for graph representation, and implements a modular architecture that allows for parallel test execution and comprehensive result analysis.

Additional Resources 📚
- YouTube Explanation
- Blog Post
EU Green Deal FAQ Bot

Overview 🔎

The EU Green Deal FAQ Bot demonstrates how to build a RAG-based AI agent that helps businesses understand EU green deal policies. The system processes complex regulatory documents into manageable chunks and provides instant, accurate answers to common questions about environmental compliance, emissions reporting, and waste management requirements.

Implementation 🛠️

Implements a sophisticated RAG pipeline using FAISS vectorstore for document storage, semantic chunking for preprocessing, and multiple specialized agents (Retriever, Summarizer, Evaluator) for query processing. The system features query rephrasing for improved accuracy, cross-reference with gold Q&A datasets for answer validation, and comprehensive evaluation metrics to ensure response quality and relevance.

Additional Resources 📚
- YouTube Explanation
Systematic Review Automation System + Paper Draft Creation

Overview 🔎

A comprehensive system for automating academic systematic reviews using a directed graph architecture and LangChain components. The system generates complete, publication-ready systematic review papers, automatically processing everything from literature search through final draft generation with multiple revision cycles.

Implementation 🛠️

Utilizes a state-based graph workflow that handles paper search and selection (up to 3 papers), PDF processing, and generates a complete academic paper with all standard sections (abstract, introduction, methods, results, conclusions, references). The system incorporates multiple revision cycles with automated critique and improvement phases, all orchestrated through LangGraph state management.

Additional Resources 📚
- YouTube Explanation
HR AI Assistant

Overview 🔎

An AI-powered recruitment assistant using LangGraph-based workflow for requirements gathering, job description generation, LinkedIn candidate search, and CV analysis.

Implementation 🛠️

Leverages LangChain and LangGraph to orchestrate a multi-step recruitment pipeline with structured state management, OpenAI for language generation, and automated candidate evaluation workflows.
AI-Driven ML and Data Science Assistant

Overview 🔎

A comprehensive ML assistant using LangGraph + OpenAI that loads datasets, performs preprocessing, feature engineering, model training, evaluation, and visualization through an agentic workflow.

Implementation 🛠️

Utilizes LangGraph for orchestrating ML pipeline tools including data preprocessing, model selection, hyperparameter tuning, and results visualization. Demonstrates end-to-end agentic ML workflows with Kaggle dataset integration.
Art Tourguide with LightRAG

Overview 🔎

An interactive art tour guide using LightRAG (knowledge-graph RAG) and LangGraph for conversational exploration of art collections with structured data retrieval.

Implementation 🛠️

Combines LightRAG for knowledge-graph-based retrieval with LangGraph agent chains, interactive widget UI, and custom art data preparation. Demonstrates a novel application of graph-based RAG in a creative domain.
Project Gutenberg Conversational Helper

Overview 🔎

A conversational agent for exploring Project Gutenberg texts using local LLMs via Ollama, with vector store RAG through Chroma/Pinecone and named entity recognition with spaCy.

Implementation 🛠️

Leverges LangGraph + Ollama for fully local LLM inference, multi-user support with session management, NER-enhanced retrieval, and dual vector store integration (Chroma for local, Pinecone for cloud).
Contextual Quoting Agentic System

Overview 🔎

A sophisticated multi-agent system for insurance/business quoting using LangGraph with RAG, specialized agents for retrieval, reasoning, classification, and quote generation.

Implementation 🛠️

Features ChromaDB for RAG, SQLite for structured data, Pydantic schemas for validation, and a coordinated workflow of specialized agents (retriever, reasoning, classification, quote generation) using OpenAI + Groq. One of the most production-relevant multi-agent implementations in this collection.

📖 Want to understand the RAG techniques powering these agents? RAG Made Simple covers 22 RAG techniques visually. Free with Kindle Unlimited.

🌟 Special Advanced Technique 🌟

Sophisticated Controllable Agent for Complex RAG Tasks 🤖

Overview 🔎

An advanced RAG solution designed to tackle complex questions that simple semantic similarity-based retrieval cannot solve. This approach uses a sophisticated deterministic graph as the "brain" 🧠 of a highly controllable autonomous agent, capable of answering non-trivial questions from your own data.

Implementation 🛠️

• Implement a multi-step process involving question anonymization, high-level planning, task breakdown, adaptive information retrieval and question answering, continuous re-planning, and rigorous answer verification to ensure grounded and accurate responses.

Prerequisites

Python 3.9+
Docker installed and running (required for some agents and setup)

Getting Started

To begin exploring and building GenAI agents:

Clone this repository:

git clone https://github.com/NirDiamant/GenAI_Agents.git

Navigate to the technique you're interested in:
```
cd all_agents_tutorials/technique-name
```
Follow the detailed implementation guide in each technique's notebook.

📚 Recommended reading

This list contains Amazon affiliate links. As an Amazon Associate I earn from qualifying purchases. Every book below is one I've read and genuinely recommend to engineers working in this space. The companion book to this repo is featured separately at the top of this README.

Build a Large Language Model (From Scratch) by Sebastian Raschka. Build a GPT-style model end to end in PyTorch.
AI Engineering: Building Applications with Foundation Models by Chip Huyen. Canonical reference for productionizing foundation-model apps.
Hands-On Large Language Models by Jay Alammar and Maarten Grootendorst. Visual, practical LLM walkthroughs.
Natural Language Processing with Transformers by Lewis Tunstall, Leandro von Werra, and Thomas Wolf. From the Hugging Face team.
Designing Machine Learning Systems by Chip Huyen. ML systems in production, still the standard reference.

Contributing

We welcome contributions from the community! If you have a new technique or improvement to suggest:

Fork the repository
Create your feature branch: git checkout -b feature/AmazingFeature
Commit your changes: git commit -m 'Add some AmazingFeature'
Push to the branch: git push origin feature/AmazingFeature
Open a pull request

Contributors

License

This project is licensed under a custom non-commercial license - see the LICENSE file for details.

⭐️ If you find this repository helpful, please consider giving it a star!

Keywords: GenAI, Generative AI, Agents, NLP, AI, Machine Learning, Natural Language Processing, LLM, Conversational AI, Task-Oriented AI

Pierian-Data/Complete-Python-3-Bootcamp

Course Files for Complete Python 3 Bootcamp Course on Udemy

Complete-Python-3-Bootcamp

Course Files for Complete Python 3 Bootcamp Course on Udemy

Get it now for 95% off with the link: https://www.udemy.com/complete-python-bootcamp/?couponCode=COMPLETE_GITHUB

Thanks!

awslabs/agentcore-samples

Amazon Bedrock Agentcore accelerates AI agents into production with the scale, reliability, and security, critical to real-world deployment.

Amazon Bedrock AgentCore Samples

Deploy and operate AI agents securely at scale - using any framework and model

Documentation ◆ Python SDK ◆ AgentCore CLI ◆ Discord

Welcome to the Amazon Bedrock AgentCore Samples repository!

Amazon Bedrock AgentCore is both framework-agnostic and model-agnostic, giving you the flexibility to deploy and operate advanced AI agents securely and at scale. Whether you’re building with Strands Agents, CrewAI, LangGraph, LlamaIndex, or any other framework—and running them on any Large Language Model (LLM)—Amazon Bedrock AgentCore provides the infrastructure to support them. By eliminating the undifferentiated heavy lifting of building and managing specialized agent infrastructure, Amazon Bedrock AgentCore lets you bring your preferred framework and model, and deploy without rewriting code.

This collection provides examples and tutorials to help you understand, implement, and integrate Amazon Bedrock AgentCore capabilities into your applications.

Migrating from the Starter Toolkit? This repository is transitioning from the Bedrock AgentCore Starter Toolkit to the new AgentCore CLI. Samples that still depend on the Starter Toolkit are in legacy/ and will be updated over the coming weeks. See MIGRATION.md for the full old-path to new-path mapping.

🎥 Video

Build your first production-ready AI agent with Amazon Bedrock AgentCore. We’ll take you beyond prototyping and show you how to productionize your first agentic AI application using Amazon Bedrock AgentCore.

📁 Repository Structure

🚀 `getting-started/`

Your First Agent in Minutes

Get up and running with the AgentCore CLI — the fastest way to create, develop, and deploy agents on Amazon Bedrock AgentCore.

python/ — Python agent samples (Code Interpreter, Gateway, Memory, Identity, and more)
typescript/ — TypeScript agent samples

🧩 `features/`

AgentCore Capabilities Deep Dives

Focused examples for individual AgentCore capabilities:

Runtime — Secure, serverless runtime for deploying agents and tools at scale
Gateway — Convert APIs, Lambda functions, and services into MCP-compatible tools
Identity — Agent identity and access management across AWS and third-party apps
Memory — Managed memory infrastructure for personalized agent experiences
Tools — Built-in Code Interpreter and Browser Tool
Observability — Trace, debug, and monitor agent performance with OpenTelemetry
Evaluation — Built-in and custom evaluators for on-demand and online evaluation
Policy — Fine-grained access control with Cedar policies

💡 `end-to-end/`

Complete Applications

Production-ready use cases that combine multiple AgentCore capabilities to solve real business problems. Each includes deployment instructions, architecture diagrams, and testing guides.

🔌 `integrations/`

Connect AgentCore to Your Stack

identity-providers/ — Okta, Entra, Cognito, and other IdP integrations
observability/ — Grafana, Datadog, Dynatrace, and other monitoring platforms
data-platforms/ — Data lake, warehouse, and analytics integrations
ux-examples/ — Streamlit, AG-UI, and other frontend patterns

🏗️ `infrastructure-as-code/`

Deployment Automation

Production-ready templates for provisioning AgentCore resources with CloudFormation, AWS CDK, or Terraform.

🚀 `blueprints/`

Full-Stack Reference Applications

Complete, deployment-ready agentic applications with integrated services, authentication, and business logic you can customize for your use case.

📦 `legacy/`

Starter Toolkit Samples (Pending Migration)

Samples that still depend on the Bedrock AgentCore Starter Toolkit CLI. These will be migrated to the AgentCore CLI as SDK support rolls out. See MIGRATION.md for status.

Quick Start with the AgentCore CLI

The AgentCore CLI is the recommended way to create, develop, and deploy agents on Amazon Bedrock AgentCore. It replaces the previous Starter Toolkit with a streamlined project-based workflow.

Step 1: Prerequisites

An AWS account with credentials configured (aws configure)
Node.js 20.x or later
uv (for Python agents) or Node.js (for TypeScript agents)
Model Access: Anthropic Claude 4.0 enabled in Amazon Bedrock console
AWS Permissions:
- BedrockAgentCoreFullAccess managed policy
- AmazonBedrockFullAccess managed policy

Step 2: Install the CLI and Create a Project

# Install the AgentCore CLI
npm install -g @aws/agentcore

# Create a new project (interactive wizard)
agentcore create
cd my-agent

The create wizard scaffolds a ready-to-run project with your choice of framework (Strands Agents, LangGraph, Google ADK, OpenAI, and more) and language (Python or TypeScript).

Step 3: Develop Locally

# Start the local development server
agentcore dev

Your agent is now running locally. The CLI watches for file changes and provides a local invocation endpoint for testing.

Step 4: Deploy to AWS

# Deploy to Amazon Bedrock AgentCore
agentcore deploy

# Test your deployed agent
agentcore invoke

Add More Capabilities

agentcore add memory           # Add managed memory
agentcore add identity         # Add identity provider
agentcore add evaluator        # Add LLM-as-a-Judge evaluation
agentcore add online-eval      # Enable continuous evaluation
agentcore deploy               # Sync changes to AWS

Congratulations! Your agent is now running on Amazon Bedrock AgentCore Runtime.

For the full CLI reference, see the AgentCore CLI documentation.

Running a Notebook

Some samples in this repository are provided as Jupyter notebooks:

Create and activate a virtual environment

python -m venv .venv
source .venv/bin/activate

Install dependencies

pip install -r requirements.txt

Export/Activate required AWS Credentials for the notebook to run
Register your virtual environment as a kernel for Jupyter notebook to use

python -m ipykernel install --user --name=notebook-venv --display-name="Python (notebook-venv)"

You can list your kernels using:

jupyter kernelspec list

Run the notebook and ensure the correct kernel is selected

jupyter notebook path/to/your/notebook.ipynb

Important: After opening the notebook in Jupyter, make sure to select the correct kernel by going to Kernel → Change kernel → select "Python (notebook-venv)" to ensure your virtual environment packages are available.

🔗 Related Links

🤝 Contributing

We welcome contributions! Please see our Contributing Guidelines for details on:

Adding new samples
Improving existing examples
Reporting issues
Suggesting enhancements

📄 License

This project is licensed under the Apache License 2.0 - see the LICENSE file for details.

Contributors

ed-donner/llm_engineering

Repo to accompany my mastering LLM engineering course

LLM Engineering - Master AI and LLMs

Your 8 week journey to proficiency starts today

If you're looking at this in Cursor, please right click on the filename in the Explorer on the left, and select "Open preview", to view the formatted version.

I'm so happy you're joining me on this path. We'll be building immensely satisfying projects in the coming weeks. Some will be easy, some will be challenging, many will ASTOUND you! The projects build on each other so you develop deeper and deeper expertise each week. One thing's for sure: you're going to have a lot of fun along the way.

IMPORTANT ANNOUNCEMENT - DECEMBER 2025 - PLEASE READ

The course material has been completely refreshed with all new weeks. If you'd prefer to stick with the code for the original videos, simply do this from your Anaconda Prompt or Terminal:
git fetch
git checkout original

Any questions, please ask me on Udemy or at ed@edwarddonner.com. More details at the top of the course resources here.

Before you begin

I'm here to help you be most successful with your learning. If you hit any snafus, or if you have any ideas on how I can improve the course, please do reach out in the platform or by emailing me direct (ed@edwarddonner.com). It's always great to connect with people on LinkedIn to build up the community - you'll find me here:
https://www.linkedin.com/in/eddonner/
And this is new to me, but I'm also trying out X/Twitter at @edwarddonner - if you're on X, please show me how it's done 😂

Resources to accompany the course, including the slides and useful links, are here:
https://edwarddonner.com/2024/11/13/llm-engineering-resources/

And a useful FAQ with common questions is here:
https://edwarddonner.com/faq/

Instant Gratification instructions for Week 1, Day 1 - with Llama 3.2 not Llama 3.3

Important note: see my warning about Llama3.3 below - it's too large for home computers! Stick with llama3.2 - several students have missed this warning...

We will start the course by installing Ollama so you can see results immediately!

Download and install Ollama from https://ollama.com noting that on a PC you might need to have administrator permissions for the install to work properly
On a PC, start a Command prompt / Powershell (Press Win + R, type cmd, and press Enter). On a Mac, start a Terminal (Applications > Utilities > Terminal).
Run ollama run llama3.2 or for smaller machines try ollama run llama3.2:1b - please note steer clear of Meta's latest model llama3.3 because at 70B parameters that's way too large for most home computers!
If this doesn't work: you may need to run ollama serve in another Powershell (Windows) or Terminal (Mac), and try step 3 again. On a PC, you may need to be running in an Admin instance of Powershell.
And if that doesn't work on your box, I've set up this on the cloud. This is on Google Colab, which will need you to have a Google account to sign in, but is free: https://colab.research.google.com/drive/1-_f5XZPsChvfU1sJ0QqCePtIuc55LSdu?usp=sharing

Any problems, please contact me!

Before the Setup instructions - a special note

Early on in the course (on Day 2), I give a demo of a very cool, popular product called Claude Code. It's an AI coding tool, similar to Cursor that we use on the course. I'm only showing this as an example of Agentic AI in action; it's not a tool that's covered explicitly on this course, particularly as we're in Cursor. But if you want to use Claude Code yourself, the Quick Start guide from Anthropic is here.

OK - now on to Setup instructions

After we do the Ollama quick project, and after I introduce myself and the course, we get to work with the full environment setup.

Hopefully I've done a decent job of making these guides bulletproof - but please contact me right away if you hit roadblocks:

Setup instructions: Setup Instructions All Platforms

An important point on API costs (which are optional! No need to spend if you don't wish)

During the course, I'll suggest you try out the leading models at the forefront of progress, known as the Frontier models. I'll also suggest you run open-source models using Google Colab. These services have some charges, but I'll keep cost minimal - like, a few cents at a time. And I'll provide alternatives if you'd prefer not to use them.

Please do monitor your API usage to ensure you're comfortable with spend; I've included links below. There's no need to spend anything more than a couple of dollars for the entire course. Some AI providers such as OpenAI require a minimum credit like $5 or local equivalent; we should only spend a fraction of it, and you'll have plenty of opportunity to put it to good use in your own projects. During Week 7 you have an option to spend a bit more if you're enjoying the process - I spend about $10 myself and the results make me very happy indeed! But it's not necessary in the least; the important part is that you focus on learning.

Free alternative to Paid APIs

See Guide 9 in the guides directory for the detailed approach with exact code for Ollama, Gemini, OpenRouter and more!

How this Repo is organized

There are folders for each of the "weeks", representing modules of the class, culminating in a powerful autonomous Agentic AI solution in Week 8 that draws on many of the prior weeks.
Follow the setup instructions above, then open the Week 1 folder and prepare for joy.

The most important part

The mantra of the course is: the best way to learn is by DOING. I don't type all the code during the course; I execute it for you to see the results. You should work along with me or after each lecture, running each cell, inspecting the objects to get a detailed understanding of what's happening. Then tweak the code and make it your own. There are juicy challenges for you throughout the course. I'd love it if you wanted to submit a Pull Request for your code (see the Github guide in the guides folder) and I can make your solutions available to others so we share in your progress; as an added benefit, you'll be recognized in GitHub for your contribution to the repo. While the projects are enjoyable, they are first and foremost designed to be educational, teaching you business skills that can be put into practice in your work.

Starting in Week 3, we'll also be using Google Colab for running with GPUs

You should be able to use the free tier or minimal spend to complete all the projects in the class. I personally signed up for Colab Pro+ and I'm loving it - but it's not required.

Learn about Google Colab and set up a Google account (if you don't already have one) here

The colab links are in the folders for Week 3 and Week 7 - if you open up the lab for each day, you'll find a direct link to the colab.

Monitoring API charges

You can keep your API spend very low throughout this course; you can monitor spend at the dashboards: here for OpenAI, here for Anthropic.

The charges for the exercsies in this course should always be quite low, but if you'd prefer to keep them minimal, then be sure to always choose the cheapest versions of models:

For OpenAI: Always use model gpt-4.1-nano in the code
For Anthropic: Always use model claude-3-haiku-20240307 in the code instead of the other Claude models
During week 7, look out for my instructions for using the cheaper dataset

Please do message me or email me at ed@edwarddonner.com if this doesn't work or if I can help with anything. I can't wait to hear how you get on.

Other resources

I've put together this webpage with useful resources for the course. This includes links to all the slides.
https://edwarddonner.com/2024/11/13/llm-engineering-resources/
Please keep this bookmarked, and I'll continue to add more useful links there over time.

fastai/fastbook

The fastai book, published as Jupyter Notebooks

English / Spanish / Korean / Chinese / Bengali / Indonesian / Italian / Portuguese / Vietnamese / Japanese

The fastai book

These notebooks cover an introduction to deep learning, fastai, and PyTorch. fastai is a layered API for deep learning; for more information, see the fastai paper. Everything in this repo is copyright Jeremy Howard and Sylvain Gugger, 2020 onwards. A selection of chapters is available to read online here.

The notebooks in this repo are used for a MOOC and form the basis of this book, which is currently available for purchase. It does not have the same GPL restrictions that are on this repository.

The code in the notebooks and python .py files is covered by the GPL v3 license; see the LICENSE file for details. The remainder (including all markdown cells in the notebooks and other prose) is not licensed for any redistribution or change of format or medium, other than making copies of the notebooks or forking this repo for your own private use. No commercial or broadcast use is allowed. We are making these materials freely available to help you learn deep learning, so please respect our copyright and these restrictions.

If you see someone hosting a copy of these materials somewhere else, please let them know that their actions are not allowed and may lead to legal action. Moreover, they would be hurting the community because we're not likely to release additional materials in this way if people ignore our copyright.

Colab

Instead of cloning this repo and opening it on your machine, you can read and work with the notebooks using Google Colab. This is the recommended approach for folks who are just getting started -- there's no need to set up a Python development environment on your own machine, since you can just work directly in your web-browser.

Contributions

If you make any pull requests to this repo, then you are assigning copyright of that work to Jeremy Howard and Sylvain Gugger. (Additionally, if you are making small edits to spelling or text, please specify the name of the file and a very brief description of what you're fixing. It's difficult for reviewers to know which corrections have already been made. Thank you.)

Citations

If you wish to cite the book, you may use the following:

@book{howard2020deep,
title={Deep Learning for Coders with Fastai and Pytorch: AI Applications Without a PhD},
author={Howard, J. and Gugger, S.},
isbn={9781492045526},
url={https://books.google.no/books?id=xd6LxgEACAAJ},
year={2020},
publisher={O'Reilly Media, Incorporated}
}

PacktPublishing/30-Agents-Every-AI-Engineer-Must-Build

30 Agents Every AI Engineer Must Build, published by Packt

30 Agents Every AI Engineer Must Build

Build production-ready agent systems using proven architectures and patterns

From the author of 50 Algorithms Every Programmer Should Know

Author: Imran Ahmad, PhD
Publisher: Packt Publishing, 2026

About This Book

The AI landscape is shifting from passive, reactive systems to autonomous, goal-directed intelligent agents—systems that perceive their environment, make decisions, and take actions with minimal human intervention. This book presents 30 essential agent architectures that every AI engineer must master to build effective, production-ready systems.

Raw LLMs alone are not enough. The key to building transformative AI systems lies in understanding how to architect agents that decompose complex tasks, connect to external tools and data sources, maintain memory across interactions, collaborate with humans and other agents, learn from experience, and make ethical decisions aligned with human values.

Each chapter includes working code, formal architectural patterns, real-world case studies, and guidance on avoiding common implementation pitfalls. Every pattern has been tested against the production realities of latency, cost, reliability, and security that define real-world deployments.

Who This Book Is For

This book is for AI engineers, software developers, ML researchers, and technical leads building intelligent systems. It's ideal for those deploying LLM-powered applications or transitioning from traditional ML to agentic frameworks. Python experience and basic ML knowledge are recommended.

Quick Start

# Clone the repository
git clone https://github.com/PacktPublishing/30-Agents-Every-AI-Engineer-Must-Build.git
cd 30-Agents-Every-AI-Engineer-Must-Build

# Navigate to a chapter
cd chapter05

# Install base dependencies
pip install -r requirements.txt

# Install your chosen provider's dependencies
pip install -r requirements-openai.txt    # For OpenAI GPT-4o
pip install -r requirements-claude.txt    # For Anthropic Claude Sonnet 4
pip install -r requirements-gemini.txt    # For Google Gemini Flash 2.5
pip install -r requirements-ollama.txt    # For local Ollama (no API key)

# (Optional) Configure your API key for Live Mode
cp .env.template .env
# Set ONE of: OPENAI_API_KEY, ANTHROPIC_API_KEY, or GOOGLE_API_KEY

# Launch the notebook
jupyter notebook ch05_foundational_architectures.ipynb

Software and Hardware Requirements

Requirement	Details
OS	macOS, Windows, or Linux
RAM	8 GB minimum; 16 GB recommended
Python	3.10 or later
GPU	NVIDIA GPU with CUDA 12+ (recommended, not required)
Tools	git, terminal, virtual environment tool (venv, conda, or uv)
API Keys	None required — every chapter runs in Simulation Mode with built-in MockLLM responses. Optional: OpenAI, Anthropic, or Google API key unlocks Live Mode. Local Ollama requires no key.
Ollama	Optional — for local LLM mode: install Ollama, then `ollama pull deepseek-v2:16b` and `ollama pull llama3.1:8b`. 16 GB+ RAM recommended.

Choose Your LLM Provider

Every chapter includes five pre-executed notebook variants — pick the one that matches your setup:

Notebook Suffix	Provider	API Key	Model
`__RUN_NO_KEY_SIMULATION`	None (MockLLM)	None	Built-in chapter-derived mock responses
`__RUN_OPENAI_GPT4o`	OpenAI	`OPENAI_API_KEY`	GPT-4o / GPT-4o-mini
`__RUN_CLAUDE_Sonnet4`	Anthropic	`ANTHROPIC_API_KEY`	Claude Sonnet 4
`__RUN_GEMINI_Flash25`	Google	`GOOGLE_API_KEY`	Gemini Flash 2.5
`__RUN_LOCAL_OLLAMA_DeepSeek_V2_16B`	Ollama (local)	None	DeepSeek V2 16B + Llama 3.1 8B embeddings

All five variants produce equivalent pedagogical output with identical cell structure. Every notebook is pre-executed with outputs saved, so you can browse them directly on GitHub without running any code.

No setup at all? Open the __RUN_NO_KEY_SIMULATION notebook — it runs entirely on MockLLM with no dependencies.
Want real LLM output? Set one API key in .env and open the matching notebook.
Prefer local inference? Install Ollama, pull the models, and open the __RUN_LOCAL_OLLAMA_DeepSeek_V2_16B notebook — no API key, no cloud calls, everything stays on your machine. See LOCAL_LLM_SETUP.md for step-by-step instructions on Windows, macOS, and Linux.
Which provider is best? See the LLM Provider Comparison Summary for head-to-head results across all 17 chapters with Bloom's taxonomy analysis, visualizations, and per-domain recommendations.

Part 1: Agent Foundations and the Engineering Toolkit

Build the conceptual and practical foundation for designing, developing, and deploying intelligent agent systems. These chapters establish the theoretical vocabulary and engineering discipline that distinguish principled agent development from ad hoc prompt engineering.

Chapter	Title	Topics	Real-World Use Case
Chapter 01	Foundations of Agent Engineering	Evolution from rule-based to LLM-powered agents · Cognitive architecture · Agent Development Lifecycle · Progression Framework	—
Chapter 02	The Agent Engineer's Toolkit	LangChain, LlamaIndex, AutoGPT · LLM selection · Vector databases · Tool integration · Cloud platforms	—
Chapter 03	The Art of Agent Prompting	System prompts · Persona construction · Agent-to-agent protocols · Chain-of-thought · Prompt version control	—
Chapter 04	Agent Deployment and Responsible Development	Infrastructure scaling · Cost management · Prompt injection defenses · Bias detection · Regulatory compliance	NovaClaim Insurance — Deploying AI agents for 40K claims/month

Part 2: Core Agent Architectures

Explore the fundamental agent architectures that serve as composable building blocks. Each architecture is designed to be combined with others to produce systems whose capabilities exceed the sum of their individual components.

Chapter	Title	Agents Covered	Real-World Use Case
Chapter 05	Foundational Cognitive Architectures	The Autonomous Decision-Making Agent · The Planning Agent · The Memory-Augmented Agent	—
Chapter 06	Information Retrieval and Knowledge Agents	The Knowledge Retrieval Agent (advanced RAG) · The Document Intelligence Agent · The Scientific Research Agent	—
Chapter 07	Tool Manipulation and Orchestration Agents	The Tool-Using Agent · The Chain-of-Agents Orchestrator · The Agentic Workflow System	ShieldPoint Insurance — 5-agent claims pipeline cutting cycle time from 12 days to 3.5
Chapter 08	Data Analysis and Reasoning Agents	The Data Analysis Agent · The Verification and Validation Agent · The General Problem Solver	—

Part 3: Specialized Application Agents

Extend core architectures into domains with stringent requirements for reliability, safety, and domain expertise. Each chapter includes production deployment considerations, a working codebase, and a real-world use case study with fictional companies, stakeholder profiles, and revenue impact analysis.

Chapter	Title	Agents Covered	Real-World Use Case
Chapter 09	Software Development Agents	The Code-Generation Agent · The Security-Hardened Agent · The Self-Improving Agent	VaultPay — Fintech startup catching PCI violations in CI/CD and fixing a declining support chatbot
Chapter 10	Conversational and Content Creation Agents	The Conversational Agent · The Content Creation Agent · The Recommendation Agent	MindBridge Health — Campus wellness platform with crisis-safe chatbot serving 31K students
Chapter 11	Multi-Modal Perception Agents	The Vision-Language Agent · The Audio Processing Agent · The Physical World Sensing Agent	Meridian Facilities — 22-building smart property management with 17% energy reduction
Chapter 12	Ethical and Explainable Agents	The Ethical Reasoning Agent · The Explainable Agent	TalentForward + ClearPath Health — Fair hiring (DI 0.73 → 0.80+) and explainable clinical diagnosis

Part 4: Domain-Specific Agent Systems with Real-World Use Cases

Apply the full range of agent architectures to transform professional domains where complexity, regulation, and human impact are most acute. Each chapter includes a detailed use case study with a fictional company navigating real industry constraints — failed alternatives, regulatory requirements, revenue impact, and a step-by-step mapping of how the code solves each problem.

Chapter	Title	Agents Covered	Real-World Use Case
Chapter 13	Healthcare and Scientific Agents	The Healthcare Intelligence Agent · The Scientific Discovery Agent	Pinnacle Health + NovaMateria Labs — Bayesian sepsis detection cutting missed cases by 79%; materials discovery compressed 60%
Chapter 14	Financial and Legal Domain Agents	The Financial Advisory Agent · The Legal Intelligence Agent	Meridian Wealth + Cartwright Legal — Compliance-by-architecture for $2.8B RIA; hallucination-proof legal research
Chapter 15	Education and Knowledge Agents	The Education Intelligence Agent · The Collective Intelligence Agent	LearnPath — Adaptive Python tutor raising completion from 52% to 78% across 12K learners
Chapter 16	Embodied and Physical World Agents	The Embodied Intelligence Agent · The Domain-Transforming Integration Agent	ArcticWing Aerial — Autonomous drone ops in Ottawa winter, scrub rate 38% → 14%
Epilogue	The Future of Intelligent Agents	Autonomous agent evolution · Agent societies and emergent behaviors · Brain-inspired cognitive architectures	—

Chapter Structure

Each chapter follows a consistent six-part structure designed for both learning and reference:

Conceptual Foundation — Core principles and architectural patterns
Implementation Guide — Detailed code examples highlighting essential components
Case Studies — Real-world applications solving practical problems
Design Patterns and Variations — Alternative approaches for different contexts
Integration Considerations — Combining agents into more powerful systems
Common Pitfalls — Avoiding typical implementation mistakes

How to Use This Book

This book accommodates three distinct reading approaches:

Sequential: Chapters 1–4 → 5–12 → 13–16 → Epilogue (full foundation to specialization)

Domain-Focused: Start with Chapters 1–4 for foundations, then jump directly to your industry vertical:

If you work in...	Start here	Then explore
Healthcare	Ch 13 (Bayesian diagnosis, scientific discovery)	Ch 12 (explainability, fairness) → Ch 11 (medical imaging)
Finance or Legal	Ch 14 (portfolio advisory, contract analysis)	Ch 4 (cost management, compliance) → Ch 12 (audit trails)
Insurance	Ch 7 (claims workflow, HITL escalation)	Ch 4 (deployment patterns) → Ch 9 (compliance scanning)
Education	Ch 15 (adaptive tutoring, knowledge tracing)	Ch 10 (conversational agents) → Ch 9 (self-improving agents)
Software Engineering	Ch 9 (code generation, PCI/HIPAA scanning)	Ch 7 (tool orchestration) → Ch 12 (explainable decisions)
Facilities / IoT	Ch 11 (sensor fusion, proportional control)	Ch 8 (data analysis) → Ch 7 (workflow automation)
Robotics / Drones	Ch 16 (safety envelopes, cascade analysis)	Ch 11 (perception agents) → Ch 4 (resilience patterns)

Reference: Look up specific agent architectures as needed for particular projects

The 30 Agents at a Glance

#	Agent	Chapter
1	The Autonomous Decision-Making Agent	Ch 5: Foundational Cognitive Architectures
2	The Planning Agent	Ch 5: Foundational Cognitive Architectures
3	The Memory-Augmented Agent	Ch 5: Foundational Cognitive Architectures
4	The Knowledge Retrieval Agent	Ch 6: Information Retrieval & Knowledge Agents
5	The Document Intelligence Agent	Ch 6: Information Retrieval & Knowledge Agents
6	The Scientific Research Agent	Ch 6: Information Retrieval & Knowledge Agents
7	The Tool-Using Agent	Ch 7: Tool Manipulation & Orchestration Agents
8	The Chain-of-Agents Orchestrator	Ch 7: Tool Manipulation & Orchestration Agents
9	The Agentic Workflow System	Ch 7: Tool Manipulation & Orchestration Agents
10	The Data Analysis Agent	Ch 8: Data Analysis & Reasoning Agents
11	The Verification and Validation Agent	Ch 8: Data Analysis & Reasoning Agents
12	The General Problem Solver	Ch 8: Data Analysis & Reasoning Agents
13	The Code-Generation Agent	Ch 9: Software Development Agents
14	The Security-Hardened Agent	Ch 9: Software Development Agents
15	The Self-Improving Agent	Ch 9: Software Development Agents
16	The Conversational Agent	Ch 10: Conversational & Content Creation Agents
17	The Content Creation Agent	Ch 10: Conversational & Content Creation Agents
18	The Recommendation Agent	Ch 10: Conversational & Content Creation Agents
19	The Vision-Language Agent	Ch 11: Multi-Modal Perception Agents
20	The Audio Processing Agent	Ch 11: Multi-Modal Perception Agents
21	The Physical World Sensing Agent	Ch 11: Multi-Modal Perception Agents
22	The Ethical Reasoning Agent	Ch 12: Ethical & Explainable Agents
23	The Explainable Agent	Ch 12: Ethical & Explainable Agents
24	The Healthcare Intelligence Agent	Ch 13: Healthcare & Scientific Agents
25	The Scientific Discovery Agent	Ch 13: Healthcare & Scientific Agents
26	The Financial Advisory Agent	Ch 14: Financial & Legal Domain Agents
27	The Legal Intelligence Agent	Ch 14: Financial & Legal Domain Agents
28	The Education Intelligence Agent	Ch 15: Education & Knowledge Agents
29	The Collective Intelligence Agent	Ch 15: Education & Knowledge Agents
30	The Embodied Intelligence Agent	Ch 16: Embodied & Physical World Agents

About the Author

Imran Ahmad on LinkedIn

Imran Ahmad, PhD is a data scientist at the Advanced Analytics Solution Center (A2SC) within the Canadian Federal Government, where he builds and deploys machine learning systems for mission-critical applications. In his 2010 doctoral thesis, he introduced a linear programming-based algorithm for optimal resource assignment in large-scale cloud computing environments. In 2017, he pioneered the development of StreamSensing, a real-time analytics framework that has become the foundation of several research papers on processing multimedia data within machine learning paradigms.

Dr. Ahmad holds a visiting professorship at Carleton University in Ottawa and is an authorized instructor for Google Cloud and Microsoft Azure. He is the author of the bestselling 50 Algorithms Every Programmer Should Know (Packt Publishing, Second Edition 2023), which has been widely adopted in both academic curricula and industry training programs. Every pattern in this book has been tested against the production realities of latency, cost, reliability, and security that define real-world deployments.

Get in Touch

General feedback: Email customercare@packt.com with the book title in the subject line.
Code issues: Open an issue on this repository.
Author: Connect with Imran Ahmad on LinkedIn

google-deepmind/deepmind-research

This repository contains implementations and illustrative code to accompany DeepMind publications

DeepMind Research

This repository contains implementations and illustrative code to accompany DeepMind publications. Along with publishing papers to accompany research conducted at DeepMind, we release open-source environments, data sets, and code to enable the broader research community to engage with our work and build upon it, with the ultimate goal of accelerating scientific progress to benefit society. For example, you can build on our implementations of the Deep Q-Network or Differential Neural Computer, or experiment in the same environments we use for our research, such as DeepMind Lab or StarCraft II.

If you enjoy building tools, environments, software libraries, and other infrastructure of the kind listed below, you can view open positions to work in related areas on our careers page.

For a full list of our publications, please see https://deepmind.com/research/publications/

Projects

Magnetic control of tokamak plasmas through deep reinforcement learning, Nature 2022
Pushing the Frontiers of Density Functionals by Solving the Fractional Electron Problem, Science 2021
Mind the Gap: Assessing Temporal Generalization in Neural Language Models, NeurIPS 2021
The Difficulty of Passive Learning in Deep Reinforcement Learning, NeurIPS 2021
Skilful precipitation nowcasting using deep generative models of radar, Nature 2021
Compute-Aided Design as Language
Encoders and ensembles for continual learning
Towards mental time travel: a hierarchical memory for reinforcement learning agents
Perceiver IO: A General Architecture for Structured Inputs & Outputs
Solving Mixed Integer Programs Using Neural Networks
A Realistic Simulation Framework for Learning with Label Noise
Rapid Task-Solving in Novel Environments, ICLR 2021
WikiGraphs: A Wikipedia - Knowledge Graph Paired Dataset, TextGraphs 2021
Behavior Priors for Efficient Reinforcement Learning
Learning Mesh-Based Simulation with Graph Networks, ICLR 2021
Open Graph Benchmark - Large-Scale Challenge (OGB-LSC)
Synthetic Returns for Long-Term Credit Assignment
A Deep Learning Approach for Characterizing Major Galaxy Mergers
Better, Faster Fermionic Neural Networks (KFAC implementation)
Object-based attention for spatio-temporal reasoning
Effective gene expression prediction from sequence by integrating long-range interactions
Satore: First-order logic saturation with atom rewriting
Characterizing signal propagation to close the performance gap in unnormalized ResNets, ICLR 2021
Uncovering the Limits of Adversarial Training against Norm-Bounded Adversarial Examples
Learning rich touch representations through cross-modal self-supervision, CoRL 2020
Functional Regularisation for Continual Learning, ICLR 2020
The Autoencoding Variational Autoencoder, NeurIPS 2020
Self-Supervised MultiModal Versatile Networks, NeurIPS 2020
ODE-GAN: Training GANs by Solving Ordinary Differential Equations, NeurIPS 2020
Algorithms for Causal Reasoning in Probability Trees
Gated Linear Networks, NeurIPS 2020
Value-driven Hindsight Modelling, NeurIPS 2020
Targeted free energy estimation via learned mappings, Journal of Chemical Physics 2020
Learning to Simulate Complex Physics with Graph Networks, ICML 2020
Physically Embedded Planning Problems
PolyGen: PolyGen: An Autoregressive Generative Model of 3D Meshes, ICML 2020
Bootstrap Your Own Latent
Catch & Carry: Reusable Neural Controllers for Vision-Guided Whole-Body Tasks, SIGGRAPH 2020
MEMO: A Deep Network For Flexible Combination Of Episodic Memories, ICLR 2020
RL Unplugged: Benchmarks for Offline Reinforcement Learning
Disentangling by Subspace Diffusion (GEOMANCER), NeurIPS 2020
What can I do here? A theory of affordances in reinforcement learning, ICML 2020
Scaling data-driven robotics with reward sketching and batch reinforcement learning, RSS 2020
Path-Specific Counterfactual Fairness, AAAI 2019
The Option Keyboard: Combining Skills in Reinforcement Learning, NeurIPS 2019
VISR - Fast Task Inference with Variational Intrinsic Successor Features, ICLR 2020
Unveiling the predictive power of static structure in glassy systems, Nature Physics 2020
Multi-Object Representation Learning with Iterative Variational Inference (IODINE)
AlphaFold CASP13, Nature 2020
Unrestricted Adversarial Challenge
Hierarchical Probabilistic U-Net (HPU-Net)
Training Language GANs from Scratch, NeurIPS 2019
Temporal Value Transport, Nature Communications 2019
Continual Unsupervised Representation Learning (CURL), NeurIPS 2019
Unsupervised Learning of Object Keypoints (Transporter), NeurIPS 2019
BigBiGAN, NeurIPS 2019
Deep Compressed Sensing, ICML 2019
Side Effects Penalties
PrediNet Architecture and Relations Game Datasets
Unsupervised Adversarial Training, NeurIPS 2019
Graph Matching Networks for Learning the Similarity of Graph Structured Objects, ICML 2019
REGAL: Transfer Learning for Fast Optimization of Computation Graphs
Deep Ensembles: A Loss Landscape Perspective
Powerpropagation
Physics Inspired Models

Disclaimer

This is not an official Google product.

GitHub Jupyter Notebook Weekly Trending

oracle-devrel/oracle-ai-developer-hub

Oracle AI Developer Hub

What You'll Find

📱 Apps (/apps)

📓 Notebooks (/notebooks)

📚 Guides (/guides)

🧠 Agent Memory (/notebooks/agent_memory)

🎓 Workshops (/workshops)

🤝 Partners (/partners)

Getting Started

Contributing

Development Setup

License

rasbt/LLMs-from-scratch

Build a Large Language Model (From Scratch)

Table of Contents

Prerequisites

Hardware Requirements

Video Course

Companion Book / Sequel

Exercises

Bonus Material

Questions, Feedback, and Contributing to This Repository

Citation

openai/openai-cookbook

License

HandsOnLLM/Hands-On-Large-Language-Models

Table of Contents

Reviews

Bonus content!

Citation

anthropics/courses

Anthropic courses

microsoft/generative-ai-for-beginners

21 Lessons teaching everything you need to know to start building Generative AI applications

🌐 Multi-Language Support

Supported via GitHub Action (Automated & Always Up-to-Date)

Generative AI for Beginners (Version 3) - A Course

🌱 Getting Started

What You Need

To run the code of this course, you can use either:

🧠 Ready to Deploy?

🗣️ Meet Other Learners, Get Support

🚀 Building a Startup?

🙏 Want to help?

📂 Each lesson includes:

🗃️ Lessons

🌟 Special thanks

🎒 Other Courses

LangChain

Azure / Edge / MCP / Agents

Generative AI Series

Core Learning

Copilot Series

Getting Help

duoan/TorchCode

title: TorchCode emoji: 🔥 colorFrom: red colorTo: yellow sdk: docker app_port: 7860 pinned: false

🔥 TorchCode

🎯 Why TorchCode?

🚀 Quick Start

Option 0 — Try it online (zero install)

Option 0b — Use the judge in Colab (pip)

Option 1 — Pull the pre-built image (fastest)

Option 2 — Build locally

📋 Problem Set

🧱 Fundamentals — "Implement X from scratch"

🧠 Attention Mechanisms — The heart of modern ML interviews

🏗️ Architecture & Adaptation — Put it all together

⚙️ Training & Optimization

🎯 Inference & Decoding

🔬 Advanced — Differentiators

⚙️ How It Works

Workflow

In-Notebook API

📅 Suggested Study Plan

🏛️ Architecture

🛠️ Commands

🧩 Adding Your Own Problems

📦 Publishing torch-judge to PyPI (maintainers)

📱 Apps (`/apps`)

📓 Notebooks (`/notebooks`)

📚 Guides (`/guides`)

🧠 Agent Memory (`/notebooks/agent_memory`)

🎓 Workshops (`/workshops`)

🤝 Partners (`/partners`)

📦 Publishing `torch-judge` to PyPI (maintainers)