Awesome Collection of Resources for Learning AI and Large Language Model (LLM) Development
Discover a comprehensive guide that covers everything from basic concepts to advanced topics, helping you navigate the exciting world of creating Generative AI (GenAI) applications using LLMs. Whether you're already developing GenAI apps or looking to enter the field, there's something here for everyone. This guide is oriented towards practical, and non-theoretical approach, advocating on hands on approach.
As someone who works on creating Generative AI applications using LLMs, not as an ML engineer but as a backend web developer, I've been asked by many people how to get started. Over the past year, I learned by doing, reading research papers, articles, blog posts, and watching YouTube videos without any particular order, basically piecing it all together. I've decided to create a curated list to help people of various background learn this in a practical manner.
Thus, I strongly encourage and welcome contributions to this list to enhance its quality and relevance.
Your input can help include valuable resources I may have missed.
Cheers 🥂
- Section 1: The Basic Concepts
- Section 2: Prompt Engineering - Basics
- Section 3: Building GenAI Apps with LLM APIs
- Section 4: Embeddings and Vector Databases
- Section 5: Retrieval Augmented Generation (RAG)
- Section 6: Advanced RAG Techniques
- Section 7: LLM AI Agents
- Section 8: LLM AI Agents Frameworks
- Appendix
- Related Awesome Currated Lists
- TODO
- What is AI, Machine Learning (ML), Deep Learning, Generative AI?
- Google's Introduction to Gen AI
- What are Large Language Models (LLMs)?
- What are tokens in LLMs?
- What are parameters in LLMs?
- What is a context window in LLMs? + How GPT works visualized in Excel
- What is temperature in LLMs?
- What are Top P and Top K in LLMs?
- How and where is Gen AI used?
- Understanding Benchmarks
Written Guide:
- Prompting Guide (Check it out too)
Videos:
- What is prompting?
- Jeff Su's Prompt Formula (Role/Persona + Context + Task/Action + Example + Format) (Similar to the CRAFT)
- Zero-Shot, First-Shot, Few-Shot Prompting
- Chain-of-Thought (CoT) Prompting
- Meta Prompting (Use AI to create really good prompts using prompt engineering)
Tips:
- Use XML tags for prompt structuring (Gives the best results)
Prerequisites Needed:
-
Using OpenAI API - Documentation (Learn how to use the OpenAI API)
-
Using ChatGPT/LLMs with OpenAI Python Package (Video for OpenAI API)
-
What are LLM Tools/Function Calls (Learn how to call function/use tools with LLMs)
-
OpenAI Assistants API (Learn OpenAI Assistant API which provides a lot of bootstraped stuff)
-
LangChain
-
Langsmith
In this section, you will learn concepts needed for implementing Retrieval Augmented Generation (RAG).
- What are Embeddings?
- What are Embeddings (More Detailed)
- Word2Vec (Blog Form) (Optional for deeper understanding)
- Vector Databases + Embeddings + Indexes (A very nice explanation, simplified)
- Using Chroma DB + OpenAI Embedding
- Using OpenAI Embeddings for CSV Search
- How to Choose a Vector Database?
Optional More In-Depth Guides About What Vector Databases Are:
- Understanding How Vector Databases Work! (Detailed, how it actually works)
- A Long-Form Very Detailed Video + Retrieval Augmented Generation (RAG)
- What is RAG?
- RAG vs Fine-Tuning
- Simple (Naive) RAG Implementation Using MongoDB
- Different Text Chunking Techniques
- Implementing RAG from Scratch + Different Techniques (Practical + Code Example)
- A Very Detailed Deep Dive into RAG + Various RAG Architectures by Stanford (More advanced, academic, theoretical approach, very detailed)
- Building Production-Ready RAG Applications: Jerry Liu (2023, a bit outdated, but nice to know)
- Advanced RAG Optimization to Make It Production-Ready
- A Survey of Production RAG Pain Points and Solutions // Jerry Liu // AI in Production Conference (2024)
- Building Production RAG Over Complex Documents - by Databricks (2024)
Pros:
- Role-Based Agent Design: Allows customization of agents with specific roles and goals, enabling cohesive operation.
- Integration with LangChain: Built on top of LangChain, providing access to a wide range of tools and models.
- User-Friendly: Simplifies the development process, making it suitable for rapid prototyping and implementation.
Cons:
- High-Level Abstraction: While easy to use initially, deeper customization can become complex due to its high-level nature.
- Dependency on LangChain: Relies on the robustness and updates of the underlying framework.
Links:
Pros:
- Stateful Graph Methodology: Allows intricate agent state tracking and updating during execution, enhancing control over processes.
- Multi-Agent Coordination: Supports multiple agents within a single graph structure, each with its own prompts, LLMs, tools, and custom code.
- Integration with LangChain: Provides access to a wide range of tools and models, enhancing agent capabilities.
Cons:
- Visual Builder Dependency: Relies on visual builders for designing applications, which may not suit teams preferring direct coding.
- Less Granular Control: May offer less control compared to direct coding methods, depending on the robustness of the LangGraph system.
Links:
Pros:
- Active Community Support: Features a very active community, beneficial for developers seeking support and collaboration.
- Customizable Agents: Offers agents that can integrate LLMs, tools, and human feedback, making task execution highly flexible.
- Memory and Context Management: Enhances utility in LLM applications demanding these features.
Cons:
- Complexity in Agent Roles: Determining the appropriate number of agents and their roles can be complex.
- Potential for Infinite Loops: Without proper tuning, agents could enter infinite loops, leading to increased computational costs and resource usage.
- Limited Support for Open-Source LLMs: Currently offers limited compatibility with open-source LLMs.
Links:
Pros:
- Ease of Learning and Use: Designed to be user-friendly, facilitating quick learning and implementation.
- Utilizes OpenAI Assistants API: Leverages OpenAI's API for robust AI capabilities.
- Built-in Tools and Agents: Provides a suite of tools and agents ready for use.
- Effective Multi-Agent Communication: Supports multiple communication methods among agents.
Cons:
- Integration Challenges: Not easily integrated into other applications.
- Small Community: Limited user base may affect support and development.
- Limited Maintenance: Maintained and developed by only a few individuals, which may impact updates and support.
Links:
- Documentation
- Crash Course
- Sample Agents
- Creating an AI Agency with Cursor AI Editor in Plain English
- Easy Deployment of AI Agencies
Production-Ready Python FastAPI Apps + Concepts:
- Multi-threading:
- Deep Dive into Asynchronous Programming with FastAPI (More advanced, for production, optional for now)
- WSGI & ASGI Simplified
- Uvicorn and FastAPI
- Production-Ready FastAPI Apps
- Logging
Things listed here are not 100% required, but it's nice to have at least a conceptual and basic understanding, which could be useful.
Useful Stuff:
How LLMs Work Under the Hood:
- Large Language Models from Scratch (Simplified) - Part 1
- Large Language Models from Scratch (Simplified) - Part 2
- 3Blue1Brown's Playlist for Neural Networks + LLMs (Very nice visualizations)
- Attention Is All You Need (Research paper that introduced the Transformers architecture)
- Attention Is All You Need - Explained (A video explanation of the research paper with nice visualizations)
- LLM Visualization Website (A very nice website that explains how LLMs/Transformers architecture works)
-
A currated list of trending research papers with code
-
A curated list of papers about large language models, especially relating to ChatGPT. It also contains frameworks for LLM training, tools to deploy LLM, courses and tutorials about LLM and all publicly available LLM checkpoints and APIs.)
-
A curated collection of awesome LLM apps built with RAG and AI agents. This repository features LLM apps that use models from OpenAI, Anthropic, Google, and even open-source models like LLaMA that you can run locally on your compute
-
A curated collection of resources for fine-tuning LLMs like GPT, BERT, and RoBERTa, featuring tutorials, tools, papers, and best practices to optimize models for specific tasks.
- Include a more advanced Prompt Engineering section - WIP
- Link additional resources - WIP
- Find and link code examples of Generative AI applications using LLMs and LLM AI Agents
- Link more of similar/on-topic repositories
- Expand the optional theoretical background section to include resources for learning ML in depth and better resources on how LLMs work under the hood
GNU General Public License v3.0