llm-app-patterns
Production-ready patterns for building LLM applications, inspired by [Dify](https://github.com/langgenius/dify) and industry best practices.
Profile →npx skills add sickn33/agentic-awesome-skills --skill llm-app-patterns --agent claude-code
Same command for any agent — swap --agent for codex, cursor, copilot.
Weekly change comes from our own snapshots, not the repository page — it measures attention, not adoption.
What it does
Provides production-ready patterns for building LLM applications, including RAG pipelines, various agent architectures, prompt IDE patterns, and LLMOps observability guidance. It outlines concrete components like chunking strategies, vector DB options, embedding models, retrieval methods, and common agent patterns (ReAct, Function Calling, Plan-and-Execute, Multi-Agent).
How it works
- RAG Pipeline Architecture: describes ingestion, embedding, retrieval, and generation steps with concrete code snippets for chunking configuration, vector DB options, embedding models, and retrieval strategies (semantic, hybrid, multi-query, compressed retrieval). Also includes a generation step using a context-aware prompt template and a return format with sources.
- Agent Architectures: details several patterns with example code structures for ReAct, Function Calling, Plan-and-Execute, and multi-agent collaboration, including prompts and class/method outlines.
- Prompt IDE Patterns: provides templates for prompts, versioning and A/B testing, and prompt chaining with an example chain (research → analyze → summarize).
- LLMOps & Observability: lists metrics to track (latency, quality, cost, reliability) and includes logging, tracing, and an example LLM call wiring with OpenTelemetry integration. The material emphasizes concrete field names, configurations, and function signatures.
When to use it
Use this skill when designing LLM-powered applications, implementing retrieval-augmented generation, building AI agents with tools, setting up LLMOps monitoring, or choosing between agent architectures.
What it can touch
Declares tools for the skill: claude-code, codex, cursor. It includes code blocks and function-like interfaces for tools such as web search, calculations, and agent actions, but it does not specify executing those tools autonomously outside of provided code patterns.
Caveats
Declares risk as critical. The content is descriptive patterns and code templates; actual integration and risk management depend on deployment context and implementation fidelity. No explicit licensing restrictions beyond general MIT license mention in metadata.
# 🤖 LLM Application Patterns > Production-ready patterns for building LLM applications, inspired by [Dify](https://github.com/langgenius/dify) and industry best practices. ## When to Use This Skill Use this skill when: - Designing LLM-powered applications - Implementing RAG (Retrieval-Augmented Generation) - Building AI agents with tools - Setting up LLMOps monitoring - Choosing between agent architectures --- ## 1. RAG Pipeline Architecture ### Overview RAG (Retrieval-Augmented Generation) grounds LLM responses in your data. ``` ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ Ingest │────▶│ Retrieve │────▶│ Generate │ │ Documents │ │ Context │ │ Response │ └─────────────┘ └─────────────┘ └─────────────┘ │ │ │ ▼ ▼ ▼ ┌─────────┐ ┌───────────┐ ┌───────────┐ │ Chunking│ │ Vector │ │ LLM │ │Embedding│ │ Search │ │ + Context│ └─────────┘ └───────────┘ └───────────┘ ``` ### 1.1 Document Ingestion ```python # Chunking strategies class ChunkingStrategy: # Fixed-size chunks (simple but may break context) FIXED_SIZE = "fixed_size" # e.g., 512 tokens # Semantic chunking (preserves meaning) SEMANTIC = "semantic" # Split on paragraphs/sections # Recursive splitting (tries multiple separators
- When to Use This Skill
- 1. RAG Pipeline Architecture
- Overview
- 1.1 Document Ingestion
- 1.2 Embedding & Storage
- 1.3 Retrieval Strategies
- 1.4 Generation with Context
- 2. Agent Architectures
- 2.1 ReAct Pattern (Reasoning + Acting)
- 2.2 Function Calling Pattern
- 2.3 Plan-and-Execute Pattern
- 2.4 Multi-Agent Collaboration
- 3. Prompt IDE Patterns
- 3.1 Prompt Templates with Variables
What does the llm-app-patterns skill do?
Production-ready patterns for building LLM applications, inspired by [Dify](https://github.com/langgenius/dify) and industry best practices.
How do I install it?
Run `npx skills add sickn33/agentic-awesome-skills --skill llm-app-patterns --agent claude-code` — it drops the skill into your project so the agent can pick it up. Swap the --agent value for codex, cursor or copilot if you use one of those.
Where does this skill come from?
From sickn33/agentic-awesome-skills, a repository with 44,414 stars. We read it straight from the repository tree rather than a submitted listing, so what you see here is what is actually published.
Is a popular skill a good skill?
Not necessarily. Stars measure attention, not adoption — a repository can trend for a week and be abandoned. That is why we show the weekly change from our own snapshots next to the total, instead of a single flattering number.