llm-app-patterns
Production-ready patterns for building LLM applications. Covers RAG pipelines, agent architectures, prompt IDEs, and LLMOps monitoring. Use when designing AI applications, implementing RAG, building agents, or setting up LLM observability.
npx skills add majiayu000/claude-skill-registry --skill antigravity-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
Instructs the agent to design and implement LLM-based applications using RAG pipelines, with defined embedding/storage options, retrieval strategies, and generation flow. Includes multiple agent architectures (ReAct, Function Calling, Plan-and-Execute, Multi-Agent teams) and guidance on Prompt IDE patterns (templates, versioning, chaining). Provides LLMOps observability metrics and basic logging/tracing for monitoring.
How it works
The skill enumerates concrete components and code patterns:
- RAG pipeline components: document ingestion with chunking strategies, embedding models and vector DB options, retrieval methods (semantic, hybrid, multi-query, compressed retrieval), and a generation workflow that constructs prompts and returns answers with sources.
- Agent architectures: ReAct with tool usage loop, Function Calling with defined tools and schemas, Plan-and-Execute executing a generated plan with potential replanning, and a Multi-Agent Team coordinating specialized agents with a critic.
- Prompt IDE patterns: prompt templates with variable validation, versioning and A/B testing of prompts, and prompt chaining that runs sequential steps with optional parsers.
- LLMOps & Observability: a set of metrics (latency, token usage, quality and cost metrics, reliability), logging via a LLMLogger class, and OpenTelemetry tracing for LLM calls.
When to use it
Use when designing LLM-powered applications, implementing RAG, building AI agents with tools, setting up LLM observability, or choosing between agent architectures.
What it can touch
Tools declared in the skill include claude-code and other tooling patterns appear in code samples (e.g., search_web, calculate). The skill describes functions, vectors, and models (e.g., openai/text-embedding-3-small, pinecone, weaviate, chromadb, pgvector) along with code blocks demonstrating their usage.
Caveats
The content provides example configurations, models, and architecture patterns; it does not guarantee performance or deployment outcomes. No additional licensing beyond MIT is stated for the skill itself in this section; usage examples reference third-party services with their own licenses.
# 🤖 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. Covers RAG pipelines, agent architectures, prompt IDEs, and LLMOps monitoring. Use when designing AI applications, implementing RAG, building agents, or setting up LLM observability.
How do I install it?
Run `npx skills add majiayu000/claude-skill-registry --skill antigravity-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 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.