LLM Application Patterns

Overview

Build production LLM applications using structured, testable patterns. Instead of manually crafting prompts, define application requirements through type-safe, composable modules that can be tested, optimized, and version-controlled like regular code.

Core principle: Program LLMs, don't prompt them.

This skill provides language-agnostic guidance on:

• Creating type-safe signatures for LLM operations
• Building composable modules and workflows
• Configuring multiple LLM providers
• Implementing agents with tools
• Testing and optimizing LLM applications
• Production deployment patterns

Core Concepts

1. Type-Safe Signatures

Define input/output contracts for LLM operations with runtime type checking.

When to use: Any LLM task, from simple classification to complex analysis.

Pattern (pseudo-code):

Signature: EmailClassification
  Description: "Classify customer support emails"

  Inputs:
    email_subject: String (required)
    email_body: String (required)

  Outputs:
    category: Enum["Technical", "Billing", "General"]
    priority: Enum["Low", "Medium", "High"]
    confidence: Float (0.0 to 1.0)

Best practices:

• Always provide clear, specific descriptions
• Use enums for constrained outputs
• Include field descriptions
• Prefer specific types over generic strings
• Define confidence scores when useful

See signatures.md for detailed patterns.

2. Composable Modules

Build reusable, chainable modules that encapsulate LLM operations.

Pattern (pseudo-code):

Module: EmailProcessor
  Initialize:
    classifier = Predict(EmailClassificationSignature)

  Forward(email_subject, email_body):
    return classifier.forward(email_subject, email_body)

Module composition - chain modules for complex workflows:

Module: CustomerServicePipeline
  Initialize:
    classifier = EmailClassifier()
    router = TicketRouter()
    responder = AutoResponder()

  Forward(email):
    classification = classifier.forward(email)
    ticket = router.forward(classification)
    response = responder.forward(ticket)
    return response

See modules.md for detailed patterns.

3. Predictor Types

Choose the right predictor for your task:

| Predictor | Use Case | Output | |-----------|----------|--------| | Predict | Simple tasks, classification, extraction | Direct output | | ChainOfThought | Complex reasoning, analysis | Reasoning + output | | ReAct | Tasks requiring tools (search, APIs) | Action sequence + output | | CodeAct | Tasks best solved with code | Generated code + execution |

When to use each:

• Predict: Classification, entity extraction, simple Q&A, summarization
• ChainOfThought: Math problems, logic puzzles, multi-step analysis, explanations
• ReAct: Research tasks, data gathering, calculator usage, API calls
• CodeAct: Data transformation, calculations, file manipulation

4. Provider Configuration

Support for multiple LLM providers with consistent interfaces.

Provider compatibility matrix:

| Feature | OpenAI | Anthropic | Gemini | Ollama | |---------|--------|-----------|--------|--------| | Structured Output | Yes | Yes | Yes | Yes | | Vision (Images) | Yes | Yes | Yes | Limited | | Image URLs | Yes | No | No | No | | Tool Calling | Yes | Yes | Yes | Varies | | Streaming | Yes | Yes | Yes | Yes |

Cost optimization strategy:

• Development: Ollama (free, local) or gpt-4o-mini (cheap)
• Testing: gpt-4o-mini with temperature=0.0 for determinism
• Production (simple): gpt-4o-mini, claude-3-haiku, gemini-flash
• Production (complex): gpt-4o, claude-3-5-sonnet, gemini-pro

See providers.md for configuration details.

Common Patterns

Multi-Step Pipeline

Pipeline: AnalysisWorkflow
  Steps:
    1. Extract → pull structured data from input
    2. Analyze → apply business logic / reasoning
    3. Summarize → produce final output

  Forward(input):
    extracted = extract.forward(input)
    analyzed = analyze.forward(extracted)
    return summarize.forward(analyzed)

Agent with Tools

Agent: ResearchAgent
  Tools:
    - WebSearch: search the internet
    - DatabaseQuery: query internal data
    - Calculator: perform calculations

  MaxIterations: 10

  Forward(question):
    Loop until answer or max iterations:
      1. Think: what do I need to know?
      2. Act: call appropriate tool
      3. Observe: process tool result
    Return final answer

Conditional Router

Router: SmartDispatcher
  Forward(input):
    classification = classifier.forward(input)

    if classification.complexity == "Simple":
      return simple_handler.forward(input)
    else:
      return complex_handler.forward(input)

Retry with Fallback

RobustModule:
  MaxRetries: 3

  Forward(input):
    for attempt in range(MaxRetries):
      try:
        return predictor.forward(input)
      catch ValidationError:
        sleep(2 ** attempt)  # exponential backoff

    return fallback_response  # or raise

Quick Start Workflow

1. Define Your Signature

What inputs do you need? What outputs do you expect?

Signature: YourTask
  Description: "What this task does"

  Inputs:
    input_field: Type

  Outputs:
    output_field: Type

2. Create a Module

Wrap the signature in a reusable module.

Module: YourModule
  Initialize:
    predictor = Predict(YourTaskSignature)

  Forward(input_field):
    return predictor.forward(input_field)

3. Configure Provider

Set up your LLM provider with appropriate settings.

Configure:
  provider: "openai/gpt-4o-mini"
  api_key: from environment
  temperature: 0.0 for determinism, 0.7 for creativity

4. Test

Write tests that verify the module's behavior.

Test: YourModule
  Given: known input
  When: module.forward(input)
  Then: output matches expected type and constraints

Implementation Libraries

| Language | Libraries | |----------|-----------| | Python | DSPy, Instructor, Outlines, Marvin, Pydantic AI | | TypeScript | Zod + OpenAI, Vercel AI SDK, LangChain.js | | Ruby | DSPy.rb, Instructor-rb | | Go | go-openai with struct validation | | Rust | async-openai with serde |

Reference Files

For detailed patterns, see:

| File | Topics | |------|--------| | signatures.md | Type-safe contract patterns, field types, validation | | modules.md | Module composition, pipelines, state management | | providers.md | Provider configuration, switching, cost optimization | | testing.md | Testing strategies, mocking, determinism | | optimization.md | Prompt optimization, few-shot learning, fine-tuning |

When to Use This Skill

Trigger this skill when:

• Implementing LLM-powered features in applications
• Creating type-safe interfaces for AI operations
• Building agent systems with tool usage
• Setting up or troubleshooting LLM providers
• Optimizing prompts and improving accuracy
• Testing LLM functionality
• Adding observability to AI applications
• Converting from manual prompts to programmatic approach
• Debugging LLM application issues