Few-shot Prompting

What is Few-shot Prompting?

Few-shot learning is a prompting technique where you provide the AI with one or several small number of examples (typically 1-10) to demonstrate the desired pattern, format, or behavior before asking it to perform a similar task. This technique leverages the AI’s ability to recognize patterns and generalize from limited examples.

Why Use Few-shot Prompting?

Improved Accuracy: Examples help the AI understand exactly what you want
Consistent Format: Ensures outputs follow a specific structure
Reduced Ambiguity: Clear examples eliminate guesswork
Better Context Understanding: Shows the AI how to handle edge cases
Domain Adaptation: Helps AI adapt to specific domains or styles

Zero-shot vs Few-shot

Zero-shot prompting involves asking the AI to perform a task without any examples, relying solely on its pre-existing knowledge. Few-shot prompting, on the other hand, provides a few examples to guide the AI’s response. Few-shot learning is generally more effective for complex tasks where context and specific patterns are crucial.

One-shot vs Few-shot

One-shot prompting provides a single example to guide the AI, the idea behind one-shot learning is to show the AI how to perform a task with just one example.

All variants of few-shot prompting (zero-shot, one-shot, and few-shot) can be implemented in Latitude. The choice depends on the complexity of the task and the amount of guidance needed.

Basic Implementation in Latitude

Here’s a simple few-shot learning example for email classification:

Email Classification

---
provider: OpenAI
model: gpt-4o
temperature: 0.1
---

# Email Classification Task

You are an expert email classifier. Based on the examples below, classify the given email
into one of these categories: URGENT, SPAM, BUSINESS, PERSONAL.

## Examples:

<user>
**Email**: "CONGRATULATIONS! You've won $1,000,000! Click here now!"
</user>
<assistant>
**Category**: SPAM
</assistant>

<user>
**Email**: "Hi John, can we reschedule tomorrow's meeting? I have a family emergency."
</user>
<assistant>
**Category**: PERSONAL
</assistant>

<user>
**Email**: "SYSTEM ALERT: Server down. Immediate attention required. Revenue impact critical."
</user>
<assistant>
**Category**: URGENT
</assistant>

<user>
**Email**: "Please find attached the Q4 financial report for your review."
</user>
<assistant>
**Category**: BUSINESS
</assistant>

## Email to Classify:
{{ email_content }}

## Category:

Advanced Implementation with Variables

Let’s create a more sophisticated example that uses Latitude’s parameters system:

---
provider: OpenAI
model: gpt-4o
temperature: 0.2
---

# {{ product_category }} Product Review Sentiment Analysis

Analyze the sentiment of {{ product_category }} reviews and extract {{ detail_level }} insights. Use the examples below as a guide.

## Examples:

{{ for example in examples }}
**Review**: "{{ example.text }}"
**Sentiment**: {{ example.sentiment }}
**Key Points**: {{ example.key_points }}
**Confidence**: {{ example.confidence }}
{{ endfor }}

## Review to Analyze:
{{ review_text }}

## Analysis:
**Sentiment**:
**Key Points**:
**Confidence**:

In this advanced example:

Dynamic Content: We use templates ({{ variable }}) to insert parameters into the prompt.
Templating Features: We demonstrate control structures like {{for item in items }} for arrays.
Runtime Examples: The examples array parameter allows users to pass in any number of examples when calling the prompt.

This pattern makes your prompts more flexible and reusable across different use cases without creating separate prompts for each scenario. For more on parameters, see the Latitude Parameter Types documentation.

Multi-step Few-shot with Chains

Latitude’s chain feature allows you to create complex few-shot workflows:

---
provider: OpenAI
model: gpt-4o
temperature: 0.1
---

<step>
# Information Extraction

Extract structured information from the business proposal. Follow these examples:

## Examples:

**Input**: "We propose a mobile app for food delivery in NYC with $50K funding needed."
**Output**:
{
  "business_type": "mobile app",
  "industry": "food delivery",
  "location": "NYC",
  "funding_needed": "$50K"
}

**Input**: "Looking for $2M Series A for our AI-powered healthcare platform serving hospitals nationwide."
```json
{
  "business_type": "AI platform",
  "industry": "healthcare",
  "location": "nationwide",
  "funding_needed": "$2M"
}
```

## Proposal to Extract:
{{ proposal_text }}

## Extracted Information:
</step>

<step>
# Business Viability Analysis

Based on the extracted information, provide a viability score following these examples:

## Examples:

**Business**: AI healthcare platform, $2M Series A, nationwide
**Viability Score**: 8.5/10
**Reasoning**: Large addressable market, proven demand, appropriate funding level

**Business**: Food delivery app, $50K seed, NYC only
**Viability Score**: 6.0/10
**Reasoning**: Competitive market, limited geographic scope, low initial funding

## Analysis:
**Viability Score**:
**Reasoning**:
</step>

Dynamic Few-shot with Conditional Logic

Use Latitude’s conditional features to adapt examples based on context:

---
provider: OpenAI
model: gpt-4o
temperature: 0.3
---

# Content Generation with Context-Aware Examples

Generate {{ content_type }} following the appropriate examples below:

{{ if content_type === "social_media" }}
  <assistant>
  ## Social Media Examples:

  **Topic**: "New restaurant opening"
  **Content**: "🍕 EXCITING NEWS! Our new pizza place opens tomorrow at 123 Main St! First 50 customers get 50% off! #GrandOpening #Pizza #Foodie"

  **Topic**: "Product launch"
  **Content**: "🚀 Introducing our game-changing productivity app! Streamline your workflow like never before. Download now: [link] #ProductLaunch #Productivity #Innovation"
  </assistant>
{{ endif }}

{{ if content_type === "email" }}
  <assistant>
  ## Email Examples:

  **Topic**: "Welcome new customer"
  **Subject**: "Welcome to [Company] - Your journey starts here!"
  **Content**: "Dear [Name], Thank you for choosing [Company]. We're excited to help you achieve your goals. Here's what to expect next..."

  **Topic**: "Product announcement"
  **Subject**: "Introducing [Product] - Transform your [Industry]"
  **Content**: "Hi [Name], We're thrilled to announce [Product], designed specifically for professionals like you who want to [benefit]..."
  </assistant>
{{ endif }}

{{ if content_type === "blog" }}
  <assistant>
  ## Blog Examples:

  **Topic**: "Industry trends"
  **Content**: "# The Future of [Industry]: 5 Trends to Watch in 2024\n\nThe [industry] landscape is evolving rapidly. Here are the key trends shaping our future:\n\n## 1. [Trend Name]\n[Detailed explanation...]"

  **Topic**: "How-to guide"
  **Content**: "# Step-by-Step Guide: How to [Action]\n\nAre you struggling with [problem]? This comprehensive guide will walk you through everything you need to know.\n\n## Prerequisites\n- [Requirement 1]\n- [Requirement 2]"
  </assistant>
{{ endif }}

## Content Request:
**Topic**: {{ topic }}
**Target Audience**: {{ audience }}
**Key Message**: {{ key_message }}

## Generated {{ content_type }}:

Few-shot with Agent Collaboration

Combine few-shot learning with Latitude’s agent system for complex workflows:

---
provider: OpenAI
model: gpt-4o
temperature: 0.2
type: agent
agents:
  - agents/data_extractor
  - agents/validator
  - agents/formatter
---

# Document Processing Pipeline

Process the document using specialized agents, each with their own few-shot examples.

## Document Input:
{{ document_content }}

## Processing Steps:

1. **Data Extraction**: Use the data_extractor agent to pull key information
2. **Validation**: Use the validator agent to verify accuracy
3. **Formatting**: Use the formatter agent to structure output

Process the document and provide the final structured result.

---
provider: OpenAI
model: gpt-4o
temperature: 0.1
type: agent
---

# Data Extraction Specialist

Extract key data points from documents following these examples:

## Examples:

**Document**: "John Smith, Software Engineer at TechCorp, joined January 2023, salary $95,000"
**Extracted Data**:
- Name: John Smith
- Position: Software Engineer
- Company: TechCorp
- Start Date: January 2023
- Salary: $95,000

**Document**: "Meeting scheduled for March 15th, 2024 at 2:00 PM in Conference Room A with the Marketing team"
**Extracted Data**:
- Event Type: Meeting
- Date: March 15th, 2024
- Time: 2:00 PM
- Location: Conference Room A
- Attendees: Marketing team

## Document to Process:
{{ document_content }}

## Extracted Data:

Best Practices for Few-shot Prompting

Example Selection

Choose Representative Examples:

Cover different scenarios and edge cases
Include both positive and negative examples
Ensure examples match your target domain
Use diverse input formats when applicable

Example Quality:

Make examples clear and unambiguous
Include enough detail without being verbose
Show consistent formatting patterns
Demonstrate the reasoning process when needed

Prompt Structure

Optimal Structure:

Task Description: Clear explanation of what you want
Examples Section: 2-10 well-chosen examples
Input Section: Where the new data goes
Output Section: Where the response should go

Formatting Tips:

Use consistent separators between examples
Clearly label input and output sections
Include field names for structured outputs
Use markdown formatting for readability

Variable Integration

Dynamic Examples:

Use Latitude variables to customize examples
Implement conditional logic for context-aware examples
Store example sets in prompt references for reusability
Allow users to provide their own examples when needed

Example with Variables:

{{ for example in examples }}
  **Input**: {{ example.input }}
  **Output**: {{ example.output }}
{{ endfor }}

Performance Optimization

Token Management:

Balance between example quantity and token efficiency
Use the most informative examples
Consider using shorter examples for simple tasks
Cache common example sets using prompt references

Model Selection:

Use more capable models (GPT-4) for complex few-shot tasks
Consider fine-tuning for repeated patterns
Adjust temperature based on creativity needs
Test with different model sizes

Advanced Techniques

Self-Improving Few-shot

Create prompts that can improve their own examples:

---
provider: OpenAI
model: gpt-4o
temperature: 0.4
---

<step>
# Process the task with current examples

Current examples:
{{ current_examples }}

Task: {{ user_task }}

Result:
</step>

<step>
# Evaluate the result quality

Result: {{ initial_processing }}

Was this result satisfactory? If not, what examples would improve future performance?

Evaluation:
</step>

<step>
# Generate improved examples if needed

Based on the evaluation. If needs improvement. Generate 2-3 new examples that would help with tasks like: {{ user_task }}
New examples should address the identified weaknesses.

Improved Examples:
</step>

Cross-Domain Transfer

Use few-shot learning to transfer patterns across domains:

---
provider: OpenAI
model: gpt-4o
temperature: 0.3
---

# Cross-Domain Pattern Transfer

Learn the pattern from {{ source_domain }} examples and apply it to {{ target_domain }}.

## Source Domain Examples ({{ source_domain }}):

{{ for example in source_examples }}
**Input**: {{ example.input }}
**Pattern Applied**: {{ example.pattern }}
**Output**: {{ example.output }}
{{ endfor }}

## Pattern Recognition:
The consistent pattern across these examples is: {{ identified_pattern }}

## Target Domain Application ({{ target_domain }}):
Now apply the same pattern to this {{ target_domain }} scenario:

**Input**: {{ target_input }}
**Pattern to Apply**: {{ identified_pattern }}
**Output**:

Common Pitfalls and Solutions

Avoid These Common Mistakes:

Too Many Examples: More isn’t always better; 3-7 examples are usually optimal
Inconsistent Formatting: Make sure all examples follow the same structure
Biased Examples: Include diverse scenarios to avoid model bias
Unclear Boundaries: Clearly separate examples from the actual task

Pro Tips:

Start with 2-3 examples and add more if needed
Test your few-shot prompts with edge cases
Use Latitude’s version control to iterate on example sets
Combine with other techniques like Chain-of-Thought for complex reasoning

Next Steps

Now that you understand few-shot learning, explore these related techniques:

Chain-of-Thought - Add reasoning steps to your examples
Template-based Prompting - Structure your few-shot examples
Role Prompting - Combine examples with specific roles
Self-Consistency - Use multiple few-shot attempts for better results

Overview

Prompting Techniques

SDK examples

Use cases

What is Few-shot Prompting?

Why Use Few-shot Prompting?

Zero-shot vs Few-shot

One-shot vs Few-shot

Basic Implementation in Latitude

Advanced Implementation with Variables

Multi-step Few-shot with Chains

Dynamic Few-shot with Conditional Logic

Few-shot with Agent Collaboration

Best Practices for Few-shot Prompting

Advanced Techniques

Self-Improving Few-shot

Cross-Domain Transfer

Common Pitfalls and Solutions

Next Steps

​What is Few-shot Prompting?

​Why Use Few-shot Prompting?

​Zero-shot vs Few-shot

​One-shot vs Few-shot

​Basic Implementation in Latitude

​Advanced Implementation with Variables

​Multi-step Few-shot with Chains

​Dynamic Few-shot with Conditional Logic

​Few-shot with Agent Collaboration

​Best Practices for Few-shot Prompting

​Advanced Techniques

​Self-Improving Few-shot

​Cross-Domain Transfer

​Common Pitfalls and Solutions

​Next Steps

What is Few-shot Prompting?

Why Use Few-shot Prompting?

Zero-shot vs Few-shot

One-shot vs Few-shot

Basic Implementation in Latitude

Advanced Implementation with Variables

Multi-step Few-shot with Chains

Dynamic Few-shot with Conditional Logic

Few-shot with Agent Collaboration

Best Practices for Few-shot Prompting

Advanced Techniques

Self-Improving Few-shot

Cross-Domain Transfer

Common Pitfalls and Solutions

Next Steps