Module 5: Advanced Prompt Engineering

❮ Back Next ❯

5.1 Prompt Chaining & Multi-step Tasks

Complex tasks often require more than one step. Prompt chaining is the technique of breaking down tasks into smaller, manageable prompts and linking their outputs and inputs in a logical flow. This allows for handling multi-step workflows with better control, accuracy, and customization.

Why Prompt Chaining?

• Break down large tasks into smaller, focused subtasks.
• Gain better quality outputs by isolating logic per step.
• Enable conditional logic and decision-making between steps.
• Allow reuse and modularity in prompting workflows.

Examples of Prompt Chaining

Example 1: Blog Writing Workflow

1. Step 1: “Generate 5 blog title ideas on the future of AI in education.”
2. Step 2: “Write an outline for the blog titled: ‘How AI is Reshaping Classrooms’.”
3. Step 3: “Expand section 1 of the outline into a 150-word paragraph.”
4. Step 4: “Summarize the blog in 3 key bullet points for social media.”

Example 2: Resume Optimization

1. Step 1: “Extract key responsibilities from this job description.”
2. Step 2: “Update my resume bullet points to align with those responsibilities.”
3. Step 3: “Write a custom cover letter referencing the job role and my updated resume.”

Example 3: Data Cleaning Pipeline

1. Step 1: “Inspect this dataset and list columns with missing values.”
2. Step 2: “Suggest the best imputation technique for each column.”
3. Step 3: “Generate Python code to apply the suggested techniques.”
4. Step 4: “Validate the cleaned data and summarize key stats.”

Example 4: App Design Flow

1. Step 1: “Describe a productivity app idea in 2–3 sentences.”
2. Step 2: “Create wireframe prompts for homepage and dashboard.”
3. Step 3: “Generate UI component code using React and Tailwind.”
4. Step 4: “Write documentation for users explaining the key features.”

Techniques for Better Prompt Chaining

• Use Systematic Prompts: Keep structure and tone consistent across steps.
• Feed Outputs as Inputs: Copy key results from one step into the next.
• Label Steps Clearly: Use numbers or section headers for each sub-task.
• Ask for Feedback: “Is there anything unclear or missing in the current output?”

Tools That Support Prompt Chaining

• Manual chaining using ChatGPT history.
• Zapier, Make (Integromat) for chaining prompts via workflows.
• LangChain, Flowise, Dust for building prompt pipelines programmatically.
• Python scripts with OpenAI API to automate multi-step prompts.

5.2 Function Calling in GPT

Function Calling is a powerful feature in GPT models (like GPT-4) that allows the model to interact with external tools or APIs. It enables the model to generate structured outputs (like JSON) that can be interpreted and executed as function calls in your code.

What is Function Calling?

Instead of returning plain text, GPT can be instructed to output a function name along with structured parameters. Your app can then call that function with those parameters and send the result back to the model for further reasoning or next steps.

Why Use Function Calling?

• Enhance GPT with real-time data (weather, databases, finance, etc.)
• Improve reliability and safety through structured outputs
• Automate workflows, connect with APIs, trigger code execution
• Enable multi-modal tools and agents (e.g. a chatbot that can search or schedule)

Example Use Case

Task: Get Weather Data

Prompt: “What’s the weather in Delhi right now?”

GPT Output:

{
  "name": "getWeather",
  "arguments": {
    "location": "Delhi"
  }
}
  

Your system executes getWeather("Delhi") and returns the result. Then GPT can respond with something like:

GPT Final Output: “It’s currently 34°C and sunny in Delhi.”

How to Use Function Calling

1. Define the function schemas (name, description, parameters)
2. Send them to the GPT model as part of your API call
3. Detect when the model wants to call a function
4. Execute that function in your app/server
5. Return the function result back to the model
6. Let GPT continue the conversation based on the result

Function Schema Format

{
  "name": "getWeather",
  "description": "Get current weather for a city",
  "parameters": {
    "type": "object",
    "properties": {
      "location": {
        "type": "string",
        "description": "The city and country"
      }
    },
    "required": ["location"]
  }
}
  

Example Applications

• Chatbots that can book flights, schedule meetings, or order food
• Financial advisors that fetch stock data or predict trends
• Customer support agents that query internal tools
• AI assistants that interact with databases or CRMs

Things to Keep in Mind

• Always validate and sanitize data before executing the function
• Secure your function execution layer (API keys, rate limits)
• Functions should return clear and concise outputs for GPT to use
• You control the list of functions – GPT can’t invent new ones

5.3 Retrieval-Augmented Generation (RAG) Basics

Retrieval-Augmented Generation (RAG) is a technique that combines the power of large language models (LLMs) like GPT with external data sources to improve accuracy and factual reliability.

What is RAG?

RAG is a method where a language model is given access to a knowledge base (documents, articles, database, etc.) through a retrieval mechanism. Instead of relying only on its trained knowledge, the model "retrieves" relevant information from a custom or real-time database and then uses that to generate responses.

Why Use RAG?

• Provides up-to-date and domain-specific knowledge
• Reduces hallucination (wrong or made-up facts)
• Increases transparency and verifiability
• Allows customization for businesses, education, research, etc.

How RAG Works

1. User asks a question
2. Retriever searches a knowledge base (e.g., PDF, website, Notion, DB) using embeddings
3. Top relevant documents are fetched (e.g., top 3 matching chunks)
4. LLM takes the documents + question as input and generates an answer

Visual Flow

User → Retriever → Top-k Docs → GPT → Final Answer
  

Example

Question: “What are the side effects of Drug X?”

RAG Flow:

• Retriever finds relevant sections from medical PDFs or research papers
• GPT reads those sections + question
• GPT generates: “The side effects of Drug X include dizziness, fatigue, and dry mouth according to Mayo Clinic guidelines.”

Components of RAG

• Embedding Model: Converts text to vectors (e.g., OpenAI, Cohere, HuggingFace)
• Vector Database: Stores and retrieves vectors (e.g., Pinecone, Weaviate, FAISS, ChromaDB)
• Retriever Logic: Matches user query vector with closest document vectors
• LLM: Uses the retrieved context to generate an answer

Applications of RAG

• AI customer support with up-to-date company policies
• Medical assistants pulling from latest research
• Chatbots for legal, HR, and educational documents
• Personal AI trained on your notes, calendar, files

Benefits

• Improves factual accuracy
• Customizable and domain-adaptable
• Combines reasoning (LLM) with facts (retriever)
• Easily integrates with existing enterprise data

Limitations

• Latency can be high if retrieval is slow
• Bad retrieval = bad answers (garbage in, garbage out)
• Need regular updating of vector database

5.4 Prompting Autonomous Agents (AutoGPT, BabyAGI)

Autonomous agents like AutoGPT and BabyAGI are AI systems built on top of language models that can think, plan, and act toward a specific goal — often without needing constant human input.

What are Autonomous Agents?

These agents use LLMs (like GPT-4) to complete multi-step tasks autonomously. Once given a high-level objective, they break it down into smaller tasks, complete them one by one, and decide the next action based on results — creating a feedback loop.

Popular Autonomous Agents

• AutoGPT: Executes tasks, calls APIs, saves results, loops until goal is reached
• BabyAGI: A lightweight version that focuses more on task prioritization and memory
• AgentGPT: A web-based version that allows goal setting through a GUI

How Do They Work?

1. User gives a high-level goal: “Create a blog post on climate change and publish it”
2. Agent breaks it down:
   • Research facts
   • Write the post
   • Generate images
   • Log in to WordPress
   • Publish article
3. Loops through each task while storing memory and updating plans based on output

Key Components

• Planning Module: Creates and prioritizes task list
• LLM: Used for reasoning, generation, decision-making
• Memory: Stores previous actions and outcomes (vector DBs, files)
• Tool Use: Access to browser, APIs, filesystem, Python code, etc.
• Agent Loop: Think → Act → Observe → Update

Prompting Tips for Autonomous Agents

• Be specific with goals (e.g., “Find trending topics in tech and write 3 tweets for each”)
• Define success criteria (e.g., “Email must be max 200 words and include a CTA”)
• Set constraints (e.g., “Do not use paid tools” or “Finish within 3 steps”)
• Enable memory for complex or long tasks

Example Use Case

Goal: “Build a competitor analysis report for Tesla”

Agent Actions:

1. Search web for EV competitors
2. Analyze their products and prices
3. Create bullet summary
4. Generate PDF report

Real-World Applications

• Automated research agents
• Task-based virtual assistants
• AI marketers writing and scheduling posts
• Financial agents monitoring stock markets

Limitations

• May loop infinitely if task isn’t well-defined
• Reliant on APIs, tools, and external systems
• Can be expensive to run (constant LLM calls)
• Still require guardrails to avoid errors

5.5 Fine-tuning vs. Prompt Engineering

What is Fine-tuning?

Fine-tuning is the process of training a pre-trained AI model (like GPT) further on special data to make it better at specific tasks. You add more training examples to adjust how the model behaves.

Example:

Suppose you have a chatbot for a hospital. You can fine-tune GPT with hospital-related questions and answers so it becomes an expert in that domain.

Pros of Fine-tuning:

• Model becomes expert in a specific field
• Gives accurate and fast responses on trained data

Cons of Fine-tuning:

• Needs a large amount of data
• Takes time, money, and technical setup
• Not flexible – model is trained on fixed examples

What is Prompt Engineering?

Prompt Engineering means giving smart and well-structured input to the AI model so it gives the best output – without retraining the model.

Example:

Instead of fine-tuning, you write a good prompt like:
"You are a medical expert. Explain what diabetes is in simple words for a 12th grade student."

Pros of Prompt Engineering:

• Fast and flexible – works instantly
• No extra cost – just good input needed
• Can guide the model to act in different roles

Cons of Prompt Engineering:

• Sometimes gives wrong answers if prompt is unclear
• Needs practice and skill to write good prompts

Comparison Table:

Feature	Fine-tuning	Prompt Engineering
Setup Time	Long	Instant
Cost	High	Low or Free
Flexibility	Low (fixed data)	High (change prompt anytime)
Use Case	When you need a custom AI model	When you want fast results without training

❮ Back Next ❯