star the repo
RepositoryFreeto get notified when new templates ship.**
Capabilities13 decomposed
curated-llm-application-template-library
Medium confidenceProvides a hierarchically-organized collection of 30+ production-ready and educational LLM application templates spanning seven architectural categories (starter agents, advanced single agents, multi-agent systems, RAG tutorials, MCP agents, voice agents, and memory-augmented apps). Templates are organized by complexity level (beginner to expert) and include complete working implementations with dependencies, configuration examples, and framework-specific patterns, enabling developers to clone, customize, and deploy reference architectures without building from scratch.
Organizes templates by architectural complexity (beginner→expert) and framework ecosystem (Agno, LangChain, LangGraph, MCP) with explicit categorization of implementation patterns (agentic RAG, database routing, corrective RAG, autonomous RAG), enabling developers to understand not just what to build but how different patterns solve different problems. Includes domain-specific agents (investment, travel, SEO audit, home renovation) demonstrating real-world application beyond generic examples.
More comprehensive than single-framework documentation because it compares Agno, LangChain, and LangGraph patterns side-by-side; more production-focused than academic papers because templates include full dependency management, UI code, and deployment considerations
framework-agnostic-agent-pattern-reference
Medium confidenceDemonstrates implementation patterns across three major agent frameworks (Agno, LangChain/LangGraph, and MCP) with explicit code examples showing how the same architectural goal (e.g., multi-agent coordination, RAG integration) is achieved differently in each framework. Includes pattern documentation for tool calling, state management, context passing, and agent composition, allowing developers to understand framework trade-offs and migrate between ecosystems.
Explicitly documents implementation patterns across three frameworks with side-by-side code examples (e.g., how Agno's Agent class with built-in tool registry differs from LangGraph's StateGraph with explicit node definitions and MCP's server-client architecture). Includes pattern categories like 'agentic RAG', 'database routing', and 'autonomous RAG' showing how each framework approaches the same problem differently.
More practical than framework documentation because it shows real-world patterns (investment agents, travel planners) implemented in multiple frameworks; more honest than marketing materials because it doesn't hide framework limitations or trade-offs
research-agent-with-gemini-interactions-api
Medium confidenceDemonstrates a production-ready research agent using Google Gemini's Interactions API for advanced reasoning and multi-turn interactions. Shows how to structure research tasks (planning, execution, synthesis), integrate web search and document retrieval, and use Gemini's reasoning capabilities for complex analysis. Enables developers to build sophisticated research and analysis agents that can decompose complex questions into research subtasks.
Demonstrates Gemini Interactions API for research agents, showing how to structure research workflows with planning (decompose research question into subtasks), execution (gather information from web and documents), and synthesis (analyze and summarize findings). Includes patterns for multi-turn interactions where the agent iteratively refines research based on intermediate results.
More specialized than generic agent templates because it focuses on research-specific patterns; leverages Gemini's reasoning capabilities which may be stronger than other models for complex analysis tasks
investment-and-finance-agent-patterns
Medium confidenceProvides production-ready implementations of AI agents for investment analysis and financial decision-making. Shows how to integrate financial data APIs (stock prices, company fundamentals, market data), implement financial reasoning patterns, and generate investment recommendations. Demonstrates domain-specific prompting for finance, risk assessment, and portfolio analysis. Enables developers to build financial advisory agents with real-time market data integration.
Demonstrates finance-specific agent patterns including integration with financial data APIs for real-time market data, domain-specific reasoning for investment analysis (fundamental analysis, technical analysis, risk assessment), and structured output for investment recommendations. Shows how to handle financial data types (OHLC prices, financial statements, market indicators) and incorporate them into LLM reasoning.
More specialized than generic agents because it includes financial domain knowledge and data integration patterns; more practical than academic finance papers because templates show real API integration and production considerations
web-scraping-agent-with-browser-automation
Medium confidenceDemonstrates web scraping agents that combine LLM reasoning with browser automation (Selenium, Playwright) to extract and analyze information from websites. Shows how agents can navigate complex websites, extract structured data, handle dynamic content, and synthesize information across multiple pages. Enables developers to build agents that can autonomously gather information from the web for analysis or monitoring.
Combines LLM reasoning with browser automation to create agents that can navigate websites, extract data, and synthesize information. Shows how agents can handle dynamic content (JavaScript-rendered pages), multi-page navigation, and complex interaction patterns. Includes patterns for error handling (broken links, missing elements) and data validation.
More intelligent than traditional web scrapers because agents can reason about page structure and adapt to changes; more flexible than static selectors because agents can understand semantic meaning of content
rag-architecture-pattern-catalog
Medium confidenceProvides implementations of seven distinct RAG patterns (Gemini Agentic RAG, Database Routing RAG, Deepseek Local RAG, Corrective RAG, Hybrid RAG, Cohere RAG Agent, Autonomous RAG with Reasoning) with complete code examples showing retrieval strategy, vector database integration, prompt engineering, and response generation. Each pattern includes architectural diagrams and trade-off analysis, enabling developers to select and implement the RAG approach best suited to their data characteristics and latency requirements.
Catalogs seven distinct RAG patterns with explicit architectural differences: Agentic RAG uses tool-calling to decide retrieval strategy dynamically; Database Routing RAG uses SQL to select which documents to retrieve; Corrective RAG performs retrieval quality assessment and re-retrieves if needed; Autonomous RAG uses reasoning to decide when to retrieve. Each pattern includes complete implementation showing vector database integration, chunking strategy, and prompt engineering specific to that pattern.
More comprehensive than single-pattern tutorials because it shows trade-offs between strategies (agentic RAG adds latency but improves relevance; corrective RAG adds cost but improves quality); more practical than academic papers because templates include vector database setup, embedding model selection, and production considerations
multi-agent-system-coordination-patterns
Medium confidenceDemonstrates multi-agent architectures through two production examples: SEO Audit Team (specialized agents for technical SEO, content analysis, backlink analysis coordinating results) and Home Renovation Agent (agents for budgeting, design, contractor coordination). Implementations show agent communication patterns (message passing, shared state, hierarchical coordination), task decomposition, and result aggregation using frameworks like Agno and LangGraph, enabling developers to build team-based AI systems where agents specialize in subtasks.
Demonstrates multi-agent coordination through concrete domain examples (SEO Audit Team with technical/content/backlink specialists; Home Renovation Agent with budget/design/contractor agents) showing how task decomposition maps to agent roles. Includes explicit coordination patterns: message passing between agents, shared context management, result aggregation, and hierarchical delegation where a coordinator agent manages subtask agents.
More concrete than abstract multi-agent frameworks because it shows real domain problems and how agents specialize; more production-focused than academic multi-agent papers because templates include error handling, timeout management, and cost optimization across parallel agent execution
mcp-protocol-agent-integration
Medium confidenceDemonstrates Model Context Protocol (MCP) integration patterns through three implementations: Travel Planner and GitHub Agents (using MCP servers for external tool access), Notion and Multi-MCP Agents (coordinating multiple MCP servers), and Browser Automation Agent (MCP for browser control). Shows how MCP's server-client architecture enables agents to access external tools and data sources through standardized protocol bindings rather than direct API calls, improving modularity and enabling tool composition.
Demonstrates MCP as a standardized protocol for agent-tool interaction, showing how Travel Planner agents access flight/hotel APIs via MCP servers, GitHub agents query repositories through MCP, and Notion agents read/write database entries. Includes multi-MCP coordination patterns where agents orchestrate multiple MCP servers, and browser automation where MCP servers expose Selenium/Playwright capabilities to agents.
More modular than direct API integration because MCP servers abstract tool details; more standardized than custom tool wrappers because MCP provides protocol guarantees; enables tool composition across multiple services without agent code changes
voice-agent-speech-integration
Medium confidenceProvides implementations of voice-enabled agents combining speech-to-text (STT) and text-to-speech (TTS) with LLM reasoning. Templates show integration patterns with speech APIs (Google Cloud Speech, OpenAI Whisper, ElevenLabs TTS), real-time audio streaming, and voice interaction loops. Enables developers to build conversational agents that accept spoken input, process it through LLM reasoning, and respond with synthesized speech.
Integrates STT (speech-to-text) and TTS (text-to-speech) with LLM agents in a complete voice interaction loop, showing how to handle real-time audio streaming, manage conversation state across voice turns, and optimize latency. Includes provider comparisons (Google Cloud Speech vs. OpenAI Whisper for STT; ElevenLabs vs. Google Cloud TTS for voice quality) and patterns for handling speech recognition errors.
More complete than individual STT/TTS tutorials because it shows the full voice agent pipeline; more practical than speech API documentation because templates include error handling, fallback mechanisms, and latency optimization patterns
memory-augmented-llm-application-patterns
Medium confidenceDemonstrates persistent conversation memory patterns enabling LLM applications to maintain context across multiple interactions. Implementations show memory storage strategies (in-memory, database, vector store), context window management, and conversation history retrieval. Enables developers to build stateful LLM applications where agents remember previous interactions, user preferences, and learned information across sessions.
Demonstrates memory patterns for LLM applications including in-memory caches for recent conversations, database storage for long-term history, and vector stores for semantic memory retrieval. Shows context window management strategies (summarization, selective retrieval) and patterns for updating memory as agents learn. Includes user preference learning and personalization based on interaction history.
More comprehensive than single-memory-type implementations because it shows trade-offs between speed (in-memory) and scale (database); more practical than academic memory papers because templates include database schema design, query optimization, and privacy considerations
domain-specific-chat-application-templates
Medium confidenceProvides specialized chat application templates for interacting with specific data sources: GitHub repositories (code search, issue analysis), PDF documents (document Q&A), and YouTube videos (transcript analysis, content summarization). Each template shows data ingestion, indexing, retrieval, and LLM-based response generation specific to that data type. Enables developers to quickly build domain-specific chatbots without implementing data source integration from scratch.
Provides turnkey templates for three specific data sources (GitHub, PDF, YouTube) with data extraction, indexing, and retrieval optimized for each type. GitHub templates show code search and issue analysis; PDF templates include document chunking and layout-aware extraction; YouTube templates handle transcript fetching and video metadata. Each includes prompt engineering specific to the data type.
More specialized than generic RAG templates because it handles data source-specific challenges (GitHub API pagination, PDF layout complexity, YouTube transcript formatting); more complete than individual library documentation because templates show end-to-end pipelines from data source to chat interface
streamlit-ui-development-patterns
Medium confidenceDemonstrates Streamlit-based UI development patterns for LLM applications, showing how to build interactive web interfaces for agents, RAG systems, and multi-agent teams. Templates include chat interfaces, real-time streaming responses, file upload handling, and agent execution visualization. Enables developers to quickly create web UIs for LLM applications without frontend expertise.
Demonstrates Streamlit patterns specific to LLM applications including chat interfaces with message history, real-time streaming of LLM responses, file upload handling for RAG systems, and agent execution visualization showing tool calls and reasoning steps. Includes patterns for managing conversation state, handling long-running agent tasks, and displaying structured results from multi-agent systems.
Faster to implement than custom React UIs because Streamlit abstracts frontend complexity; more suitable for LLM applications than generic Streamlit tutorials because templates show agent-specific patterns (streaming, tool visualization, conversation management)
vector-database-integration-patterns
Medium confidenceDemonstrates integration patterns for multiple vector databases (Pinecone, Weaviate, Chroma, Faiss) in RAG and memory systems. Shows data ingestion, embedding generation, semantic search, and result retrieval with different database backends. Enables developers to choose and integrate vector databases based on deployment constraints (cloud vs. local, managed vs. self-hosted, scale requirements).
Demonstrates integration patterns for four vector database backends (Pinecone cloud-managed, Weaviate self-hosted, Chroma lightweight, Faiss local) showing how to ingest documents, generate embeddings, perform semantic search, and retrieve results. Includes patterns for handling different embedding models, similarity metrics, and index types. Shows trade-offs between managed (Pinecone) and self-hosted (Weaviate, Faiss) options.
More comprehensive than single-database documentation because it shows how to switch between backends; more practical than academic vector database papers because templates include production considerations (scaling, cost, latency)
Capabilities are decomposed by AI analysis. Each maps to specific user intents and improves with match feedback.
Related Artifactssharing capabilities
Artifacts that share capabilities with star the repo, ranked by overlap. Discovered automatically through the match graph.
awesome-llm-apps
100+ AI Agent & RAG apps you can actually run — clone, customize, ship.
create-llama
LlamaIndex CLI to scaffold full-stack RAG applications.
awesome-generative-ai
A curated list of Generative AI tools, works, models, and references
DecryptPrompt
总结Prompt&LLM论文,开源数据&模型,AIGC应用
awesome-generative-ai-guide
A one stop repository for generative AI research updates, interview resources, notebooks and much more!
llm-course
Course to get into Large Language Models (LLMs) with roadmaps and Colab notebooks.
Best For
- ✓developers building LLM agents for the first time seeking reference implementations
- ✓teams evaluating different agent frameworks (Agno, LangChain, LangGraph) before committing
- ✓researchers studying multi-agent coordination patterns and RAG architectures
- ✓startup founders prototyping AI-powered products with limited ML expertise
- ✓architects choosing between agent frameworks for new projects
- ✓teams migrating from one framework to another
- ✓developers building framework-agnostic agent abstractions
- ✓researchers comparing agent framework design decisions
Known Limitations
- ⚠Templates are snapshots — may lag behind latest framework versions or API changes
- ⚠No built-in CI/CD or automated testing across all templates; maintenance burden on community
- ⚠Requires manual adaptation for production use; templates assume specific API keys and environment configurations
- ⚠Documentation depth varies by template; some advanced patterns lack detailed explanation
- ⚠Pattern documentation is implicit in code examples rather than explicit comparison tables
- ⚠Framework versions may diverge; templates may not reflect latest API changes across all three ecosystems simultaneously
Requirements
Input / Output
UnfragileRank
UnfragileRank is computed from adoption signals, documentation quality, ecosystem connectivity, match graph feedback, and freshness. No artifact can pay for a higher rank.
About
to get notified when new templates ship.**
Categories
Alternatives to star the repo
Are you the builder of star the repo?
Claim this artifact to get a verified badge, access match analytics, see which intents users search for, and manage your listing.
Get the weekly brief
New tools, rising stars, and what's actually worth your time. No spam.
Data Sources
Looking for something else?
Search →