awesome-llm-apps

Provides 100+ production-ready agent implementations across three primary frameworks (Agno, LangChain/LangGraph, and native Python) organized by complexity tier (starter, advanced single-agent, multi-agent). Each implementation includes complete dependency specifications, environment configuration templates, and runnable entry points, allowing developers to clone and immediately execute agents without framework-specific boilerplate. The repository uses a tiered complexity model where starter agents demonstrate basic tool-calling patterns, advanced agents implement planner-executor architectures with state management, and multi-agent systems showcase coordination via message passing or shared context.

Implements 8+ distinct RAG architectures (basic retrieval, corrective RAG, hybrid retrieval, database routing, agentic RAG, autonomous RAG, RAG with reasoning) with working code for each pattern. Each implementation demonstrates a specific retrieval strategy: basic RAG uses vector similarity search, corrective RAG adds a grading step to filter irrelevant chunks, hybrid RAG combines vector and keyword search, database routing uses an LLM to select which database to query, and agentic RAG treats retrieval as a tool the agent can invoke iteratively. Implementations support multiple vector databases (Pinecone, Weaviate, Chroma, FAISS) and document sources (PDFs, web pages, databases, code repositories).

Implements specialized agents for financial analysis and investment decisions that integrate real-time market data, financial APIs, and domain-specific reasoning. The investment agent can fetch stock prices, analyze financial statements, calculate metrics (P/E ratio, dividend yield), and provide investment recommendations. Integration with financial data providers (Alpha Vantage, Finnhub, or similar) enables real-time market data access. The agent uses domain-specific prompts and reasoning patterns for financial analysis, handles numerical precision and currency conversions, and provides citations to data sources. Examples include portfolio analysis agents, stock recommendation agents, and market trend analysis agents.

Implements agents that can browse the web, scrape content, and extract information from dynamic websites using browser automation (Selenium, Playwright, or Puppeteer). The web scraping agent can navigate websites, interact with forms and buttons, wait for dynamic content to load, and extract structured data. Integration with agent frameworks allows the agent to decide what to scrape, how to navigate, and how to extract information based on user requests. Examples include competitive intelligence agents that scrape competitor websites, price monitoring agents that track product prices, and content aggregation agents that gather information from multiple sources. The agent handles JavaScript-heavy sites and can wait for content to load before extraction.

Implements advanced RAG patterns that improve retrieval quality beyond basic vector similarity search. Corrective RAG adds a grading step where an LLM evaluates whether retrieved documents are relevant to the query; if not, the system reformulates the query and retrieves again. Hybrid RAG combines multiple retrieval strategies (vector similarity, keyword search, semantic search) and ranks results by combining scores from different methods. Implementations demonstrate how to define relevance criteria, implement grading logic, and combine retrieval scores. The corrective approach trades latency for quality (additional LLM calls), while hybrid approaches balance different retrieval strengths.

Demonstrates MCP protocol integration for agents that need to interact with external systems (GitHub, Notion, browsers, file systems) through standardized tool schemas. Implementations show how to define MCP tool specifications (input schemas, descriptions), bind them to agent frameworks (Agno, LangChain), and handle tool execution with error recovery. The repository includes examples of travel planning agents using MCP for flight/hotel APIs, GitHub agents using MCP for repository operations, and browser automation agents using MCP for web scraping, all following the MCP specification for tool discovery and invocation.

Implements multi-agent systems where specialized agents (e.g., SEO auditor, content writer, technical reviewer) coordinate via message passing or shared state to solve complex tasks. Examples include an SEO audit team where one agent crawls websites, another analyzes content, and a third generates recommendations; a home renovation agent where one agent gathers requirements, another estimates costs, and a third creates project plans. Coordination patterns include sequential task handoff (agent A completes, passes results to agent B), parallel execution with result aggregation, and hierarchical delegation (manager agent assigns tasks to worker agents). Implementations use either explicit message queues or shared context objects to pass information between agents.

Implements research agents that decompose complex research queries into sub-questions, search the web for relevant information, synthesize findings, and iteratively refine results. The research agent uses a planner-executor pattern: a planner LLM breaks down 'research X' into specific search queries, an executor searches the web and retrieves documents, and a synthesizer combines results into a coherent report. Integration with Google Gemini Interactions API enables real-time web search within agent reasoning loops. The agent can iterate — if initial results are insufficient, it generates follow-up queries and searches again. Outputs include structured research reports with source citations and confidence scores.

Implements voice-based agents that accept audio input, transcribe it to text, process through an LLM agent, and synthesize responses back to speech. The voice agent pipeline uses a speech-to-text service (e.g., Google Speech-to-Text, Deepgram) to convert audio to text, passes the text to an agent for processing, and uses a text-to-speech service (e.g., Google TTS, ElevenLabs) to convert the agent's response back to audio. Implementations handle audio streaming, real-time transcription, and low-latency synthesis. Examples include voice-based travel planners, customer service agents, and accessibility-focused applications.

Implements agents with persistent conversation history and context management, allowing multi-turn interactions where the agent remembers previous exchanges and maintains coherent context. Patterns include simple conversation history (storing all messages), summarization-based memory (periodically summarizing old messages to save tokens), entity-based memory (tracking important entities and their attributes), and hybrid approaches combining multiple memory strategies. Implementations use local storage (SQLite, JSON files) or external services (Redis, Supabase) for persistence. The agent can retrieve relevant context from history, update memory as new information emerges, and manage context window size to stay within LLM token limits.

Provides pre-built agent templates for interacting with specific data sources: GitHub agents for repository analysis and code search, PDF chat agents for document Q&A, YouTube transcript agents for video content analysis, and similar domain-specific implementations. Each template includes data source connectors (GitHub API client, PDF parser, YouTube API), specialized prompts for the domain, and example use cases. The GitHub agent can search repositories, analyze code, and answer questions about codebases; the PDF agent can extract text, handle multi-page documents, and cite specific pages; the YouTube agent can fetch transcripts and summarize video content. Templates are designed to be cloned and customized for specific domains.

Demonstrates running agents entirely locally using open-source LLMs (Deepseek, Mistral, Llama) via Ollama, eliminating dependency on cloud LLM APIs. Implementations show how to configure Agno or LangChain agents to use local Ollama endpoints, handle model-specific prompt formatting, and manage local inference latency. Examples include local RAG agents (combining local LLM with local vector database like FAISS), local research agents (using local search or document retrieval), and local multi-agent systems. The local approach trades cloud API costs for local compute resources and enables offline operation.

Provides Streamlit-based UI templates for visualizing agent execution, displaying reasoning steps, and enabling user interaction with agents. Implementations show how to build agent dashboards that display agent state, tool calls, and reasoning traces in real-time. Streamlit integration allows rapid UI prototyping without frontend development — agents can be wrapped with a Streamlit app that handles user input, displays agent responses, and visualizes execution flow. Examples include research agent dashboards showing search queries and results, multi-agent system dashboards showing agent coordination, and RAG dashboards showing retrieved documents and relevance scores.