Day 2: Prompt Engineering Basics with LangChain

Welcome to Day 2 of our LangChain + AWS Bedrock journey! Today we dive into the art and science of prompt engineering - the skill that transforms simple text into powerful AI interactions.

What We'll Learn Today

• 
  Zero-shot prompting: Getting results without examples


• 
  Few-shot prompting: Learning from examples
  


• 
  Role prompting: Making AI adopt specific personas


• 
  Model parameters: Fine-tuning AI behavior (temperature, top_p, max_tokens)

Setup (Continuing from Day 1)

Assuming you have the packages and bedrock client from Day 1, let's initialize our Claude model with specific parameters for today's experiments:

from langchain_aws import ChatBedrock

from langchain.prompts import PromptTemplate



# Initialize Claude with parameters for prompt engineering

llm = ChatBedrock(

    model_id="anthropic.claude-3-sonnet-20240229-v1:0",

    region_name="us-east-1",

    model_kwargs={

        "max_tokens": 150,

        "temperature": 0.7,

        "top_p": 0.9

    }

)

Understanding Prompt Engineering

Prompt engineering is the art of crafting instructions that guide AI models to produce desired outputs. Think of it like being a director giving instructions to an actor - the clearer and more specific your direction, the better the performance.

The key principles are:

• 
  Clarity: Be specific about what you want


• 
  Context: Provide relevant background information


• 
  Constraints: Set boundaries (length, format, tone)


• 
  Examples: Show the desired output style when needed

1. Zero-Shot Prompting

Zero-shot prompting is like asking someone to perform a task they've never seen before, relying purely on their general knowledge and understanding. The model uses its pre-trained knowledge without any specific examples.

When to use Zero-shot:

• Simple, well-defined tasks


• When the model already understands the domain


• For general knowledge questions


• When you want the model's "natural" response

Advantages:

• Quick and simple


• No need to prepare examples


• Works well for common tasks

Limitations:

• May not follow specific formats


• Less control over output style


• Can be inconsistent for complex tasks
  

# Zero-shot prompt - no examples given

zero_shot_prompt = PromptTemplate(

    input_variables=["service"],

    template="Explain {service} in simple terms for a beginner."

)



# Use it

prompt = zero_shot_prompt.format(service="Amazon S3")

response = llm.invoke(prompt)

print(response.content)

2. Few-Shot Prompting

Few-shot prompting is like showing someone examples before asking them to do a task. You provide 2-5 examples of the desired input-output pattern, then ask the model to follow the same pattern.

When to use Few-shot:

• When you need consistent formatting


• For complex or unusual tasks


• When zero-shot results are inconsistent


• To establish a specific style or tone

Advantages:

• Better control over output format


• More consistent results


• Can teach complex patterns


• Reduces need for detailed instructions

Best practices:

• Use 2-5 examples (more isn't always better)


• Make examples diverse but consistent


• Show edge cases if relevant


• Keep examples concise
  

# Few-Shot Prompting



few_shot_prompt = PromptTemplate(

    input_variables=["service"],

    template="""

Explain AWS services using this format:



Example 1:

Service: Amazon EC2

Simple Explanation: Virtual computers in the cloud that you can rent by the hour.



Example 2:

Service: Amazon RDS

Simple Explanation: Managed database service that handles backups and updates automatically.



Now explain:

Service: {service}

Simple Explanation:"""

)



# Use the few-shot prompt

prompt = few_shot_prompt.format(service="Amazon Lambda")

response = llm.invoke(prompt)

print(response.content)

3. Role Prompting

Role prompting assigns a specific identity, profession, or perspective to the AI. It's like asking the model to "act as" someone with particular expertise, personality, or viewpoint.

Why Role Prompting works:

• Models have learned associations between roles and communication styles


• Provides context for appropriate language and knowledge level


• Helps generate more engaging and targeted responses


• Leverages the model's understanding of different perspectives

Types of roles:

• 
  Professional roles: "You are a software architect", "You are a teacher"


• 
  Personality traits: "You are enthusiastic", "You are patient and methodical"


• 
  Expertise levels: "You are a beginner", "You are an expert"


• 
  Creative personas: "You are a poet", "You are a storyteller"

Best practices:

• Be specific about the role's characteristics


• Include relevant context about the audience


• Combine roles with other prompting techniques


• Test different roles to find what works best
  

role_prompt = PromptTemplate(

    input_variables=["service", "role"],

    template="""

You are a {role}. Explain {service} from your perspective.

Keep it engaging and use language appropriate to your role.

"""

)



# Test different roles

roles = ["friendly teacher", "creative poet", "cricket commentator"]



for role in roles:

    print(f"\n{role.title()}:")

    prompt = role_prompt.format(service="Amazon Lambda", role=role)

    response = llm.invoke(prompt)

    print(response.content)

    print("-" * 40)

Model Parameters

The model_kwargs parameter controls AI behavior:

Key Parameters

• 
  max_tokens: Response length (50-150 for short, 200-500 for detailed)


• 
  temperature: Creativity level (0.2 = focused, 0.7 = balanced, 0.9 = creative)


• 
  top_p: Word diversity (0.8 = focused, 0.9 = balanced)

Quick Examples

# Factual responses

factual_kwargs = {"max_tokens": 150, "temperature": 0.2, "top_p": 0.8}



# Creative responses  

creative_kwargs = {"max_tokens": 300, "temperature": 0.9, "top_p": 0.95}

Key Takeaways

Core Prompting Techniques:

1. 
   Zero-shot: Direct instructions, relies on model knowledge


2. 
   Few-shot: Provide examples to guide format and style


3. 
   Role prompting: Adopt personas for engaging explanations

Model Control:

1. 
   Parameters: Fine-tune behavior with temperature, top_p, max_tokens

Best Practices

Getting Started:

1. 
   Start Simple: Begin with zero-shot, add complexity as needed


2. 
   Be Specific: Vague prompts lead to inconsistent results


3. 
   Test Iteratively: Refine prompts based on outputs

Improving Results:

1. 
   Use Examples: Show don't just tell what you want


2. 
   Set Constraints: Guide the model with clear boundaries


3. 
   Consider Context: Provide relevant background information

Optimization:

1. 
   Monitor Parameters: Adjust temperature and top_p for your use case


2. 
   Test Edge Cases: Try unusual inputs to test robustness

Common Pitfalls to Avoid

• 
  Over-prompting: Too many instructions can confuse the model


• 
  Ambiguous language: Be precise in your requirements
  


• 
  Ignoring context length: Very long prompts may get truncated


• 
  Not testing edge cases: Try unusual inputs to test robustness


• 
  Fixed parameters: Different tasks need different temperature/top_p values


• 
  Inconsistent examples: Make sure few-shot examples follow the same pattern

About Me

Hi! I'm Utkarsh, a Cloud Specialist & AWS Community Builder who loves turning complex AWS topics into fun chai-time stories ☕

👉 Explore more

This is part of my "LangChain with AWS Bedrock: A Developer's Journey" series. Follow along as I document everything I learn, including the mistakes and the victories.