llm-app-patterns
Production-ready patterns for building LLM applications, inspired by [Dify](https://github.com/langgenius/dify) and industry best practices.
npx skills add majiayu000/claude-skill-registry --skill llm-app-patterns-sickn33-antigravity-awesome --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
Describes patterns and concrete implementations for building LLM-powered applications, focusing on Retrieval-Augmented Generation (RAG), document ingestion and embedding strategies, various agent architectures (ReAct, Function Calling, Plan-and-Execute, Multi-Agent collaboration), Prompt IDE patterns (templates, versioning, chaining), and LLMOps/observability (metrics, logging, tracing). The material includes code-style examples, configuration snippets, and usage scenarios to guide design and implementation decisions.
How it works
- RAG Pipeline Architecture: outlines ingestion, retrieval, and generation steps, with specific chunking settings, embedding storage options, and retrieval strategies (semantic, hybrid, multi-query, compressed retrieval). Provides concrete Python-like snippets for chunk config, vector DB choices, and embedding models.
- Generation with Context: defines a template prompt that constrains the LLM to answer based on retrieved context and return sources.
- Agent Architectures: details several patterns and corresponding code scaffolds for ReAct, Function Calling, Plan-and-Execute, and Multi-Agent teams, including prompt schemas and execution loops.
- Prompt IDE Patterns: covers Prompts with variables, versioning and A/B testing, and Prompt Chaining with a stepwise chain that passes output between steps.
- LLMOps & Observability: lists metrics (latency, quality, cost, reliability), logging and tracing primitives, and a sample function demonstrating tracing and logging hooks for LLM calls.
When to use it
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
What it can touch
- Tools declared: claude-code
- Code-like patterns and function definitions for searching, computing, and orchestrating prompts and agents are included throughout the examples.
- It provides concrete identifiers for models, vector DBs, and prompt templates, and shows how to wire tool calls and responses in agent loops.
Caveats
- Risk: unknown
- License: MIT
- Source is described as community-driven with examples; no explicit guarantees of production readiness beyond the presented patterns and configurations. The material emphasizes patterns and structures rather than a single turnkey implementation, and some snippets assume surrounding infrastructure (LLM, vector store, and tooling) exists.
# 🤖 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 majiayu000/claude-skill-registry --skill llm-app-patterns-sickn33-antigravity-awesome --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 majiayu000/claude-skill-registry, a repository with 534 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.