Awesome LLM Apps: Building Production-Ready AI Agents and Applications

Overview

This course walks you through the Awesome LLM Apps repository—a curated, hands‑on collection of more than 100 ready‑to‑run AI agent and retrieval‑augmented generation (RAG) templates. You will learn how to clone, customize, and ship production‑grade LLM applications without rebuilding common pipelines from scratch. The material covers the full modern AI stack: single‑file starter agents, advanced multi‑agent systems, voice‑enabled agents, Model Context Protocol (MCP) integrations, RAG pipelines, agent skills, memory‑enabled chatbots, fine‑tuning recipes, and framework‑specific crash courses. By the end of the course you will be able to pick any template, adapt it to your data or use case, and deploy it with just a few commands.

Background & Context

The Awesome LLM Apps project was created and is maintained by Shubham Saboo, with contributions from a vibrant open‑source community. It exists because developers repeatedly waste time reinventing the same foundational components—RAG pipelines, agent loops, MCP integrations, voice pipelines—when starting a new LLM project. The repository solves this problem by providing self‑contained, end‑to‑end tested templates that can be forked, customized, and shipped as production applications. Every template includes full source code, a minimal requirements.txt, and a three‑command quick‑start workflow, eliminating the “figure it out yourself” scaffolding that plagues many open‑source AI repos.

The project is provider‑agnostic: you can switch between Claude, Gemini, GPT‑4, xAI Groq, Qwen, Llama, and other models by changing a single configuration value. This flexibility lets teams experiment with different LLMs without rewriting agent logic. All code is released under the Apache‑2.0 license, meaning you can fork, modify, sell, or embed the templates in commercial products without paying royalties or dealing with telemetry.

Each featured template is accompanied by a free step‑by‑step tutorial on Unwind AI, ensuring that newcomers can follow along from clone to running demo. The repository is organized into thematic categories (Starter AI Agents, Advanced AI Agents, Multi‑agent Teams, etc.) that map directly to the concepts covered in this course.

Core Concepts

AI Agents (Starter & Advanced)

Starter AI agents are single‑file programs that require only an API key to run. Examples from the repository include the AI Blog to Podcast Agent, which fetches a blog post, summarizes it, and generates a podcast‑style audio script; the AI Breakup Recovery Agent, which offers empathetic chat‑based support using a fine‑tuned sentiment model; and the AI Data Analysis Agent, which loads a CSV, runs pandas‑based exploratory analysis, and returns natural‑language insights. The AI Medical Imaging Agent demonstrates how to ingest DICOM or PNG images, run a pretrained vision model (e.g., a chest‑X‑ray classifier), and produce a radiology‑style report.

Advanced AI agents add tools, memory, and multi‑step reasoning. The AI Home Renovation Agent with Nano Banana Pro takes a photo of a room, uses a vision‑language model to propose redesigns, and then calls a 3D rendering tool to generate a before/after visualization. The DevPulse AI – Multi‑Agent Signal Intelligence system coordinates a scraper agent, a sentiment‑analysis agent, and a trading‑signal agent to produce real‑time market alerts. Other advanced agents include the AI Deep Research Agent (which formulates sub‑questions, searches the web, and synthesizes a report), the AI VC Due Diligence Agent Team (a group of agents that evaluate startup metrics, market size, and founder backgrounds), and the AI Financial Coach Agent (which tracks user spending, suggests budgets, and answers tax‑related queries).

Multi‑Agent Teams

Multi‑agent teams consist of two or more specialized agents that communicate via a shared blackboard or message‑passing protocol to solve cross‑domain problems. The repository lists dozens of pre‑built teams:

AI Competitor Intelligence Agent Team – one agent scrapes competitor websites, another extracts pricing data, a third summarizes news, and a fourth generates a SWOT report.
AI Finance Agent Team – includes a data‑ingestion agent (SEC filings), a risk‑scoring agent, and a portfolio‑optimization agent.
AI Game Design Agent Team – a narrative agent creates story beats, a mechanics agent balances gameplay, and an art‑direction agent proposes asset styles.
AG2 Adaptive Research Team – uses the AG2 framework to dynamically allocate tasks based on agent performance.
AI Legal Agent Team (Cloud & Local) – one agent extracts clauses from contracts, another checks jurisdiction‑specific compliance, and a third drafts plain‑language summaries.
AI Recruitment Agent Team – parses resumes, matches skills to job descriptions, and generates outreach emails.
AI Real Estate Agent Team – pulls MLS listings, computes comparable‑sale valuations, and creates virtual tour scripts.
AI Services Agency (CrewAI) – demonstrates the CrewAI framework for orchestrating a fleet of service‑oriented agents (e.g., scheduling, invoicing, customer support).
AI Teaching Agent Team – generates lesson plans, creates quiz questions, and provides feedback on student submissions.
Multimodal Coding Agent Team – writes code, runs unit tests, and documents functions in a single loop.
Multimodal Design Agent Team – produces UI mockups, suggests color palettes, and writes CSS.
Multimodal UI/UX Feedback Agent Team with Nano Banana – analyzes user‑submitted screenshots, proposes accessibility improvements, and generates A/B test variants.
AI Travel Planner Agent Team – aggregates flight data, hotel availability, and local attractions to build personalized itineraries.

These teams illustrate how complex workflows can be decomposed into reusable, testable agents that can be swapped or scaled independently.

Autonomous Game‑Playing Agents

The repository includes agents that play games end‑to‑end, combining perception, reasoning, and action. The AI 3D Pygame Agent uses a reinforcement‑learning policy to navigate a 3D maze rendered with Pygame, receiving pixel observations and outputting joint torques. The AI Chess Agent integrates a chess engine (e.g., Stockfish) with an LLM that explains each move in natural language, enabling a hybrid of brute‑force search and linguistic justification. The AI Tic‑Tac‑Toe Agent demonstrates a simple minimax solver wrapped in an LLM‑driven dialogue system that can teach beginners the optimal strategy. These examples show how game logic can be encapsulated as a tool that an LLM agent calls, while the LLM handles strategy explanation, curriculum generation, or commentary.

Voice AI Agents

Voice agents process spoken input and produce spoken output using real‑time voice APIs. The AI Audio Tour Agent takes a user’s location, fetches Wikipedia entries for nearby landmarks, and narrates them via a text‑to‑speech (TTS) pipeline. The Customer Support Voice Agent listens to a caller’s complaint, extracts intent via a speech‑to‑text (STT) model, queries a knowledge base, and responds with a synthesized voice answer. The Insurance Claim Live Agent Team combines a voice‑input agent (using Gemini Live), a document‑understanding agent (to parse photos of damage), and a claims‑processing agent that guides the user through filing steps. The Voice RAG Agent (OpenAI SDK) shows how to embed a retrieval pipeline into a voice loop: the user speaks a query, the system transcribes it, retrieves relevant passages from a vector store, and reads the answer aloud. Finally, the OpenSource Voice Dictation Agent (Wispr Flow clone) provides a self‑hosted alternative to commercial dictation software, using Whisper for STT and a custom language model for punctuation restoration.

MCP AI Agents

Model Context Protocol (MCP) agents connect LLMs to external tools and data sources through a standardized interface. The repository provides:

Browser MCP Agent – exposes functions like navigate(url), click(selector), and extract_text() so an LLM can automate web browsing.
GitHub MCP Agent – offers list_repos(), create_issue(), search_code(), enabling agents to manage repositories programmatically.
Notion MCP Agent – provides query_database(), update_page(), append_block() for interacting with Notion workspaces.
AI Travel Planner MCP Agent – wraps travel‑booking APIs (flights, hotels, car rentals) as MCP tools, allowing an agent to plan end‑to‑end trips.
Multi‑MCP Agent Router – dynamically selects the appropriate MCP server based on the user's intent, enabling a single agent to switch between browsing, GitHub, and Notion without reconfiguration.

These agents illustrate how MCP turns any API or SDK into a callable tool that an LLM can reason about, eliminating the need for custom glue code.

RAG (Retrieval Augmented Generation) Tutorials

RAG pipelines combine a retriever (often vector‑based) with a generator to ground LLM outputs in external knowledge. The repository covers a wide spectrum:

Agentic RAG with Embedding Gemma – uses Gemma embeddings to retrieve passages, then an agent decides whether to re‑rank, rewrite, or ask clarifying questions.
Agentic RAG with Reasoning – integrates a reasoning module (e.g., chain‑of‑thought) that evaluates retrieved evidence before generating an answer.
AI Blog Search (RAG) – indexes a personal blog with FAISS, allowing natural‑language queries to return relevant posts with citations.
Autonomous RAG – the agent formulates sub‑queries, retrieves, and iterates until a confidence threshold is met.
Contextual AI RAG Agent – maintains a sliding window of conversation context to improve retrieval relevance for follow‑up questions.
Corrective RAG (CRAG) – detects hallucinations by comparing generated text with source snippets and triggers a retrieval‑correction loop.
Deepseek Local RAG Agent – runs the Deepseek‑Coder model locally, paired with a local FAISS index for code‑search tasks.
Gemini Agentic RAG – leverages Gemini’s multimodal understanding to retrieve images or audio alongside text.
Hybrid Search RAG (Cloud) – combines BM25 keyword search with dense vector retrieval for robustness.
Llama 3.1 Local RAG – demonstrates how to run Llama 3.1 on a consumer GPU with a local vector store.
Local Hybrid Search RAG – merges TF‑IDF and cosine similarity on a CPU‑only setup.
Multimodal Agentic RAG – retrieves both text and images, then uses a vision‑language model to answer questions about visual content.
Local RAG Agent – a minimal pipeline using Sentence‑Transformers embeddings and a simple FAISS index.
RAG‑as‑a‑Service – exposes a REST endpoint that accepts a query and returns a grounded answer, ready for integration into larger systems.
RAG Agent with Cohere – uses Cohere’s embeddings and reranker to improve precision.
Basic RAG Chain – the classic retrieve‑then‑generate pattern with LangChain‑style chaining.
RAG with Database Routing – routes queries to different databases (e.g., SQL for structured data, vector store for unstructured text) based on intent classification.
Vision RAG – indexes images with CLIP embeddings, enabling natural‑language image search.
RAG Failure Diagnostics Clinic – a debugging tool that logs retrieval scores, token usage, and hallucination flags to help tune the pipeline.
Knowledge Graph RAG with Citations – combines a Neo4j knowledge graph with vector retrieval, providing graph‑traversed answers with source citations.

Each tutorial includes a ready‑to‑run script, a sample dataset, and instructions for swapping the retriever or generator.

Awesome Agent Skills

Agent skills are reusable, modular units of behavior that can be plugged into any agent workflow. The repository highlights the Self‑Improving Agent Skills skill set, which uses Gemini and the Agent Development Kit (ADK) to automatically tune skill parameters (e.g., temperature, token limits, tool selection) based on performance metrics. The repository also provides a browseable list of 19 skills, ranging from summarize_text, extract_entities, generate_sql, translate_language, to detect_sentiment and schedule_meeting. Each skill is versioned, documented, and can be imported via a simple Python import statement, encouraging a plug‑and‑play approach to agent development.

LLM Apps with Memory

Memory‑enabled agents retain conversation history or user state across sessions, enabling personalized experiences. Examples include:

AI ArXiv Agent with Memory – remembers which papers a user has read, suggests new reads based on topic affinity, and can answer follow‑up questions about previously discussed articles.
AI Travel Agent with Memory – stores past trip preferences (budget, travel dates, accommodation type) and uses them to pre‑fill future search forms.
Llama3 Stateful Chat – a chatbot that keeps a rolling window of the last N turns in a SQLite database, allowing context‑aware replies over extended conversations.
LLM App with Personalized Memory – integrates a user profile (likes, dislikes, goals) into the prompt via a memory module that retrieves relevant facts before each response.
Local ChatGPT Clone with Memory – mimics ChatGPT’s conversation persistence using a local vector store for embeddings and a simple key‑value store for session data.
Multi‑LLM Application with Shared Memory – demonstrates how multiple agents (possibly powered by different LLMs) can read from and write to a shared Redis‑based memory store, enabling cooperative problem solving.

These implementations show patterns such as short‑term memory (recent turns), long‑term memory (user profiles, fact bases), and shared memory (inter‑agent communication).

Chat with X Tutorials

The “Chat with X” series turns arbitrary data sources into conversational interfaces. The repository provides:

Chat with GitHub (GPT & Llama3) – lets users ask natural‑language questions about repository activity (e.g., “Show me open bugs labeled good‑first‑issue”).
Chat with Gmail – enables searching emails, summarizing threads, and drafting replies via voice or text.
Chat with PDF (GPT & Llama3) – extracts text from PDFs, indexes it, and answers questions with citations to specific pages.
Chat with Research Papers (ArXiv) (GPT & Llama3) – indexes ArXiv abstracts and full‑text PDFs, allowing researchers to ask “What are the latest techniques for diffusion models in 2024?”
Chat with Substack – turns a newsletter archive into a searchable, chat‑based knowledge base.
Chat with YouTube Videos – downloads transcripts, creates a vector index, and lets users query video content by timestamp.

Each tutorial includes a script that authenticates to the source (if needed), extracts text, builds an index (FAISS, Annoy, or Chroma), and wraps a simple Gradio or Streamlit UI around a retrieval‑augmented LLM.

LLM Optimization Tools

Optimization tools reduce token usage, context size, and API cost while preserving output quality.

Toonify Token Optimization – converts prompts into a compact “TOON” format (a token‑efficient representation of structured data) that can cut API costs by 30‑60 %. The tool works by replacing repetitive JSON keys with short placeholders and reconstructing the original structure on the server side.
Headroom Context Optimization – dynamically trims irrelevant conversation history, keeping only the most salient tokens, achieving 50‑90 % reduction in context length without degrading task performance. It uses a scoring function based on TF‑IDF similarity to the current query.

Both tools are provided as drop‑in Python modules that can be wrapped around any LLM call.

LLM Fine‑tuning Tutorials

Fine‑tuning adapts pretrained open‑source models to specific domains or tasks. The repository contains step‑by‑step guides for:

Gemma 3 Fine‑tuning – shows how to load Gemma‑3B, prepare a instruction‑following dataset (e.g., Alpaca format), apply LoRA adapters, and train on a single RTX 3090.
Llama 3.2 Fine‑tuning – walks through quantization‑aware training (QLoRA) for Llama‑3.2‑8B, dataset mixing (instruction + RLHF), and evaluation on MT‑Bench and MMLU.

Each tutorial includes the exact accelerate launch command, a sample training_args.json, and instructions for exporting the merged model for inference with transformers.

AI Agent Framework Crash Courses

Crash courses give developers a rapid, hands‑on introduction to major agent frameworks.

Google ADK Crash Course – covers: creating a starter agent that is model‑agnostic (works with OpenAI, Claude, Gemini); defining structured outputs with Pyd

flowchart LR
    A[Clone Awesome LLM Apps repo] --> B[Browse templates]
    B --> C[Select a template (agent, RAG, voice, etc.)]
    C --> D[Customize template (data, prompts, config)]
    D --> E[Install dependencies (pip install -r requirements.txt)]
    E --> F[Run quick-start (e.g., python app.py)]
    F --> G[Test locally]
    G --> H[Deploy to production (Docker, cloud)]

← Previous