Most marketers treat AI like a magic box: prompt goes in, content comes out. But AI models are more like highly skilled interns—they need clear instructions, context, and examples to do their best work.

The quality of your AI output is directly determined by the quality of your prompts. Master prompt engineering, and you can:

• Generate SEO content that actually ranks (not generic fluff)
• Automate repetitive SEO tasks without sacrificing quality
• Analyze competitors and extract insights at scale
• Create content briefs, meta descriptions, and schema markup in seconds
• Conduct keyword research with semantic understanding

This article covers a wide range of these techniques from this amazing repo, providing concrete examples and practical code implementations to help you create high-quality, optimized content that resonates with both search engines and your target audience.

Let’s break down the techniques by category and show you exactly how to use them for SEO.

Basic Techniques: The Foundation

1. Zero-Shot Prompting

What it is: Giving the AI a task without any examples—just a clear instruction.

SEO Use Case: Quick meta description generation

Example Prompt:

Write a meta description for a blog post titled "How to Reduce Cart Abandonment in E-commerce."
The meta description should be 150-155 characters, include the keyword "reduce cart abandonment,"
and create urgency.

When to use it: Fast, one-off tasks where you need a straightforward answer.

---

2. Few-Shot Prompting

What it is: Providing 2-5 examples of the desired output format before asking for new content.

SEO Use Case: Creating consistent product descriptions across an e-commerce catalog

Example Prompt:

You are an e-commerce copywriter. Write product descriptions following these examples:

Example 1:
Product: Wireless Bluetooth Headphones
Description: Immerse yourself in crystal-clear sound with our Wireless Bluetooth Headphones.
Featuring 40-hour battery life, active noise cancellation, and ultra-comfortable ear cushions,
these headphones are perfect for commuters, travelers, and audiophiles alike.

Example 2:
Product: Stainless Steel Water Bottle
Description: Stay hydrated in style with our Stainless Steel Water Bottle. Double-wall vacuum
insulation keeps drinks cold for 24 hours or hot for 12 hours. BPA-free, leak-proof, and
available in 6 vibrant colors.

Now write a product description for: Organic Cotton Yoga Mat

When to use it: When you need consistent formatting, tone, and structure across multiple pieces of content.

---

3. Role Prompting

What it is: Instructing the AI to adopt a specific persona or expertise level.

SEO Use Case: Creating expert-level content that demonstrates E-E-A-T (Experience, Expertise, Authoritativeness, Trustworthiness)

Example Prompt:

You are a certified nutritionist with 15 years of experience specializing in plant-based diets.
Write a 300-word section for a blog post explaining the protein requirements for vegan athletes.
Use evidence-based information and cite general nutritional guidelines.

When to use it: When you need content that sounds authoritative and matches a specific expertise level.

---

4. Emotion Prompting

What it is: Adding emotional cues or urgency to prompts to influence the AI’s tone and style.

SEO Use Case: Creating compelling calls-to-action and engaging introductions

Example Prompt:

Write an introduction for a blog post about cybersecurity threats facing small businesses.
The tone should create a sense of urgency and concern without being alarmist. Make the reader
feel that this information is critical for protecting their business.

When to use it: Landing pages, email campaigns, and content where emotional resonance matters.

---

5. Batch Prompting

What it is: Processing multiple inputs in a single prompt to save time.

SEO Use Case: Generating title tag variations for A/B testing

Example Prompt:

Generate 5 different title tag variations for each of these pages. Each title should be 50-60
characters, include the primary keyword, and have a unique angle:

1. Page about "email marketing automation"
2. Page about "social media scheduling tools"
3. Page about "content calendar templates"

When to use it: When you have multiple similar tasks that can be processed together.

---

Advanced Reasoning Techniques

6. Zero-Shot Chain of Thought (CoT)

What it is: Asking the AI to “think step by step” before providing an answer.

SEO Use Case: Keyword research and search intent analysis

Example Prompt:

I want to rank for "best project management software." Let's think step by step:

1. First, analyze the search intent behind this keyword
2. Then, identify what type of content currently ranks for this term
3. Next, determine what subtopics and related keywords should be covered
4. Finally, suggest a content structure that would be competitive

Provide your analysis.

When to use it: Complex SEO strategy questions that require reasoning.

---

7. Few-Shot Chain of Thought

What it is: Providing examples of step-by-step reasoning, then asking the AI to apply the same logic.

SEO Use Case: Competitive content analysis

Example Prompt:

I'll show you how to analyze a competitor's blog post, then you'll do the same for a new URL.

Example Analysis:
URL: competitor.com/guide-to-seo
Step 1: Word count is 3,200 words
Step 2: Includes 15 H2 subheadings covering keyword research, on-page SEO, link building
Step 3: Has 8 custom images and 2 embedded videos
Step 4: Internal links to 12 related articles
Step 5: Conclusion: Comprehensive, multimedia-rich, well-structured

Now analyze this URL: competitor.com/content-marketing-strategy

When to use it: Teaching the AI your specific analysis framework.

---

8. Self-Ask Prompting

What it is: The AI generates its own sub-questions and answers them sequentially.

SEO Use Case: Creating comprehensive FAQ sections

Example Prompt:

I'm writing a guide about "starting a podcast." Generate a list of questions a beginner would
ask, then answer each one in 2-3 sentences. Format it as an FAQ section suitable for schema markup.

When to use it: FAQ pages, “People Also Ask” optimization, and comprehensive guides.

---

9. Analogical Prompting

What it is: The AI generates its own relevant examples before solving the problem.

SEO Use Case: Creating relatable content for complex topics

Example Prompt:

Explain how Google's PageRank algorithm works by first thinking of an analogous real-world system,
then using that analogy to explain the concept in simple terms for a non-technical audience.

When to use it: Making technical SEO concepts accessible to clients or broader audiences.

---

10. Meta Prompting

What it is: Providing a structured blueprint plus step-by-step reasoning.

SEO Use Case: Creating detailed content briefs

Example Prompt:

Create a content brief for a blog post targeting the keyword "how to improve website speed."

Use this structure:
1. Primary keyword and search intent
2. Target audience and their pain points
3. Competitive analysis (top 3 ranking pages)
4. Recommended word count and content depth
5. Required subtopics and H2/H3 structure
6. Internal linking opportunities
7. Call-to-action recommendation

Think through each section systematically and provide detailed recommendations.

When to use it: Comprehensive SEO planning and content strategy.

---

Advanced Break Down Techniques

11. Least-to-Most Prompting

What it is: Breaking a complex problem into smaller sub-problems and solving them sequentially.

SEO Use Case: Technical SEO audits

Example Prompt:

I need to audit a website's technical SEO. Let's break this down from simplest to most complex:

1. First, check if the site has a robots.txt and XML sitemap
2. Then, analyze page speed scores
3. Next, review mobile-friendliness
4. After that, check for broken links and redirect chains
5. Then, examine structured data implementation
6. Finally, assess crawl budget and indexation issues

Start with step 1 and work through each systematically.

When to use it: Complex, multi-step SEO processes.

---

12. Plan and Solve Prompting

What it is: The AI creates a plan first, then executes it step-by-step.

SEO Use Case: Content gap analysis

Example Prompt:

I want to identify content gaps between my site and my competitor's site.

First, create a plan for how to conduct this analysis.
Then, execute the plan using these URLs:
- My site: mysite.com/blog
- Competitor: competitor.com/blog

Provide actionable recommendations.

When to use it: Strategic SEO projects that benefit from upfront planning.

---

13. Program of Thoughts (PoT)

What it is: Generating code or symbolic steps to solve a problem precisely.

SEO Use Case: Creating regex patterns for htaccess redirects

Example Prompt:

I'm migrating a blog from /blog/post-title/ to /articles/post-title/

Generate the Apache .htaccess redirect rules needed to:
1. Redirect all /blog/ URLs to /articles/
2. Preserve the slug
3. Use 301 redirects
4. Handle both www and non-www versions

Provide the exact code.

When to use it: Technical implementations requiring precise syntax.

---

Advanced Ensemble Techniques

14. Self-Consistency Prompting

What it is: Generating multiple reasoning paths and picking the most common answer.

SEO Use Case: Validating keyword difficulty assessments

Example Prompt:

Analyze the keyword "best CRM software" and determine its difficulty level (Easy/Medium/Hard/Very Hard).

Generate 3 different analyses using different reasoning approaches:
1. Based on domain authority of ranking pages
2. Based on content depth and quality of top results
3. Based on backlink profiles of ranking pages

Then, provide a final consensus difficulty rating.

When to use it: Important decisions where you want multiple perspectives.

---

15. Multi-Chain Reasoning

What it is: Multiple reasoning paths that are synthesized into a superior final answer.

SEO Use Case: Comprehensive content strategy development

Example Prompt:

I want to create a content strategy for a B2B SaaS company selling project management software.

Approach this from three angles:
1. Keyword research and search demand analysis
2. Competitor content gap analysis
3. Customer journey and intent mapping

Then, synthesize these three analyses into a unified 6-month content roadmap.

When to use it: High-stakes strategy work requiring multiple analytical lenses.

---

Advanced Critique Techniques

16. Self-Refine Prompting

What it is: The AI generates content, critiques it, then improves it iteratively.

SEO Use Case: Optimizing existing content

Example Prompt:

Here's a blog post introduction:

"SEO is important for businesses. It helps you get more traffic. In this post, we'll talk about SEO."

First, critique this introduction and identify what's wrong with it from an SEO and engagement perspective.
Then, rewrite it to be compelling, keyword-optimized, and hook the reader immediately.

When to use it: Improving underperforming content.

---

17. Chain of Verification

What it is: Draft an answer, verify it independently, then correct it.

SEO Use Case: Fact-checking AI-generated content

Example Prompt:

Write a paragraph explaining how Google's Core Web Vitals affect rankings.

Then, verify each claim you made:
1. Is this factually accurate based on official Google documentation?
2. Are there any outdated or incorrect statements?
3. Are there important nuances missing?

Finally, provide a corrected version if needed.

When to use it: Ensuring accuracy in informational content.

---

Advanced Multilingual Techniques

18. Chain of Translation

What it is: Translate first, then perform the task for clearer reasoning.

SEO Use Case: International SEO and multilingual keyword research

Example Prompt:

I want to target Spanish-speaking users searching for "how to lose weight."

First, translate this keyword into Spanish and identify the most natural phrasing.
Then, research related long-tail keywords in Spanish.
Finally, suggest content topics that would resonate with Spanish-speaking audiences.

When to use it: Expanding into international markets.

---

Advanced Multi-Step Techniques

19. Rephrase and Respond

What it is: Rewrite the question clearly, then answer the clarified version.

SEO Use Case: Understanding ambiguous search queries

Example Prompt:

A user searches for "apple optimization."

First, rephrase this query to clarify what the user likely means (are they asking about Apple device optimization, apple orchard optimization, or something else?).

Then, provide 3 possible interpretations and suggest what type of content would satisfy each intent.

When to use it: Ambiguous keywords or search queries.

---

20. Step-Back Prompting

What it is: Identify the general principle first, then solve the specific problem.

SEO Use Case: Diagnosing ranking drops

Example Prompt:

My website's rankings dropped 30% last week.

First, step back and explain the general principles of why rankings drop (algorithm updates, technical issues, competitor improvements, etc.).

Then, apply those principles to diagnose my specific situation and recommend a troubleshooting process.

When to use it: Problem-solving that benefits from first-principles thinking.

---

Practical SEO Workflows Using These Techniques

Workflow 1: Creating a Pillar Page

Combine: Role Prompting + Meta Prompting + Self-Refine

Step 1 (Role + Meta): "You are an SEO content strategist. Create a detailed outline for a pillar
page about 'email marketing' including primary keyword, search intent, H2/H3 structure, internal
linking strategy, and word count recommendation."

Step 2 (Self-Refine): "Review this outline. Is it comprehensive enough to compete with the top 3
ranking pages? What's missing? Improve the outline based on your critique."

Step 3: "Now write the introduction section following the improved outline."

---

Workflow 2: Competitive Content Analysis

Combine: Few-Shot CoT + Batch Prompting

"I'll show you how to analyze one competitor article, then you'll analyze 5 more.

Example:
URL: competitor.com/seo-guide
- Word count: 2,800
- Headings: 12 H2s covering keyword research, on-page, technical, link building
- Media: 6 screenshots, 1 infographic
- Links: 8 internal, 3 external to authority sites
- Unique angle: Focuses on local SEO

Now analyze these 5 URLs: [list URLs]"

---

Workflow 3: Keyword Clustering

Combine: Zero-Shot CoT + Self-Consistency

"I have these 20 keywords: [list]. Let's think step by step:

1. First, group them by search intent (informational, commercial, transactional)
2. Then, cluster them by topic similarity
3. Next, identify which clusters should target the same page vs. separate pages
4. Finally, recommend a URL structure for each cluster

Generate 3 different clustering approaches, then provide your recommended final structure."

---

Implementation Tips

Start Simple: Begin with basic techniques (Zero-Shot, Few-Shot, Role) before moving to advanced methods.

Iterate: Don’t expect perfect output on the first try. Refine your prompts based on results.

Combine Techniques: The real power comes from chaining multiple techniques together.

Save Your Best Prompts: Build a prompt library for recurring SEO tasks.

Test and Measure: Compare AI-generated content performance against human-written content.

---

Prompt engineering isn’t about replacing human expertise—it’s about amplifying it. These 29 techniques give you a structured framework for getting better results from AI tools, whether you’re doing keyword research, creating content, or conducting technical audits.

The marketers who win in the AI era won’t be the ones who use AI the most. They’ll be the ones who use it the best.

Technical Reference & Deep Dive

Implementation Details (using LangChain)

Here are Python implementations using LangChain (v1.0) to showcase these techniques with the Gemini model. These examples will classify news headlines and extract key phrases.

Prerequisites:

• Google Gemini API key (obtained via Google AI Studio).
• Python environment with LangChain, Google Generative AI, and Pydantic installed:

pip install langchain langchain-google-genai pydantic

import os
from google.colab import userdata  # Adjust if not using Colab
from langchain.chat_models import init_chat_model
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import PydanticOutputParser
from pydantic import BaseModel, Field
from typing import List

# 1. Set your API key (REPLACE with your actual key)
os.environ["GOOGLE_API_KEY"] = userdata.get('GOOGLE_API_KEY') # Or os.environ["GOOGLE_API_KEY"] = "YOUR_API_KEY" if not using Colab

# 2. Initialize the chat model (using Gemini - adjust as needed)
model = init_chat_model(
"gemini-2.5-flash",
model_provider="google_genai",
temperature=0  # Set temperature for deterministic output
)

A. Zero-Shot Implementation (News Headline Classification)

# 3. Define the Pydantic schema for structured output
class ZeroShotClassifyResponse(BaseModel):
predicted_label: str = Field(..., description="Predicted news category")

# 4. Create the parser
parser = PydanticOutputParser(pydantic_object=ZeroShotClassifyResponse)

# 5. Zero-shot prompt template (no examples)
prompt_template = ChatPromptTemplate.from_template(
"""
Classify the news headline into one of the categories:
["Politics", "Sports", "Business", "Technology", "Entertainment", "Health", "World"]

Headline: {headline}

Provide your output in this JSON format:
{format_instructions}
"""
)

# 6. Inject parser instructions
prompt = prompt_template.partial(format_instructions=parser.get_format_instructions())

# 7. Chain: prompt → model → parser
chain = prompt | model | parser

# 8. Example headline
headline = "Government approves new policy to boost semiconductor manufacturing."

# 9. Invoke
result = chain.invoke({"headline": headline})

# 10. Display result
print("\n--- Predicted Label ---\n", result.predicted_label) # Expected output: Politics

B. Few-Shot Implementation (Key Phrase Extraction)

# 3. Define the Pydantic schema for structured output
class KeyPhraseResponse(BaseModel):
key_phrases: List[str] = Field(..., description="List of extracted key phrases")

# 4. Create parser
parser = PydanticOutputParser(pydantic_object=KeyPhraseResponse)

# 5. Few-shot prompt with examples
prompt_template = ChatPromptTemplate.from_template(
"""
Extract the most important key phrases from the text.
Key phrases should be meaningful, concise, and capture core concepts.

Here are some examples:

Example 1:
Text: "Climate change is accelerating due to rising greenhouse gas emissions."
Key Phrases: ["climate change", "greenhouse gas emissions"]

Example 2:
Text: "Machine learning models require large datasets for effective training."
Key Phrases: ["machine learning models", "large datasets", "effective training"]

Example 3:
Text: "Renewable energy sources like solar and wind are becoming more affordable."
Key Phrases: ["renewable energy sources", "solar", "wind", "affordable energy"]

Now extract key phrases from the following text:

Text:
{input_text}

Provide the output in this JSON format:
{format_instructions}
"""
)

# 6. Inject parser instructions
prompt = prompt_template.partial(format_instructions=parser.get_format_instructions())

# 7. Build LCEL chain
chain = prompt | model | parser

# 8. Example text
input_text = "Artificial intelligence is transforming healthcare by enabling faster diagnosis, personalized treatments, and advanced medical imaging."

# 9. Invoke
result = chain.invoke({"input_text": input_text})

# 10. Display results
print("\n--- Key Phrases ---\n", result.key_phrases)

C. Role Prompting (News Headline Classification)

# 3. Define the Pydantic schema for structured output
class ZeroShotClassifyResponse(BaseModel):
predicted_label: str = Field(..., description="Predicted news category")

# 4. Create the parser
parser = PydanticOutputParser(pydantic_object=ZeroShotClassifyResponse)

# 5. Role Prompting template (no examples)
prompt_template = ChatPromptTemplate.from_template(
"""
You are a professional news editor with years of experience in global journalism. Your job is to accurately classify news headlines into their correct category.
Classify the news headline into one of the categories:
["Politics", "Sports", "Business", "Technology", "Entertainment", "Health", "World"]

Headline: {headline}

Provide your output in this JSON format:
{format_instructions}
"""
)

# 6. Inject parser instructions
prompt = prompt_template.partial(format_instructions=parser.get_format_instructions())

# 7. Chain: prompt → model → parser
chain = prompt | model | parser

# 8. Example headline
headline = "Government approves new policy to boost semiconductor manufacturing."

# 9. Invoke
result = chain.invoke({"headline": headline})

# 10. Display result
print("\n--- Predicted Label ---\n", result.predicted_label)

II. Advanced Prompting Techniques for AI SEO

These techniques significantly enhance the LLM’s ability to create optimized content.

1. Chain-of-Thought (CoT) Prompting

Concept: Instruct the LLM to “think step-by-step” before providing a final answer. This encourages more logical and accurate reasoning, leading to better content.

AI SEO Angle: Helps the LLM create content that is more insightful, comprehensive, and logically structured, resembling high-quality content that Google favors. Use CoT prompting to create in-depth analyses and tutorials.

# Define the Pydantic schema for structured output
class CoTResponse(BaseModel):
reasoning_chain: str = Field(..., description="Step-by-step reasoning")
answer: str = Field(..., description="Final numeric answer only")

# Create the parser from the Pydantic model
parser = PydanticOutputParser(pydantic_object=CoTResponse)

# Prompt template with explicit zero-shot CoT cue ("Let's think step by step.")
prompt_template = ChatPromptTemplate.from_template(
"""
You are a step-by-step reasoning assistant.

Question: {question}

Answer: Let's think step by step.

Provide your solution in the following JSON format:
{format_instructions}

"""
)

# Inject the parser's format instructions into the template
prompt = prompt_template.partial(format_instructions=parser.get_format_instructions())

# Build the LCEL chain (prompt → model → parser)
chain = prompt | model | parser

# Example question and invocation
question = "A baker made 24 cookies. Half are chocolate chip. Half of those have sprinkles. How many chocolate-chip cookies with sprinkles?"

result = chain.invoke({"question": question})

# Display the result
print("\n--- Reasoning Chain ---\n", result.reasoning_chain)
print("\n--- Final Answer ---\n", result.answer)

SEO Example: Ask the LLM to explain the benefits of a specific SEO tool using CoT. The step-by-step breakdown can become a valuable section in your content.

2. Chain-of-Draft (CoD) Prompting

Concept: Similar to CoT, but the LLM uses very short, compact reasoning steps (3-5 words max) to reduce response length, token cost, and response time.

AI SEO Angle: CoD helps generate focused, concise content that gets straight to the point. Ideal for creating summaries, bullet points, or quick-reference guides.

# Define the Pydantic schema for structured output
class CoTResponse(BaseModel):
reasoning_chain: str = Field(..., description="Step-by-step reasoning")
answer: str = Field(..., description="Final numeric answer only")

# Create the parser from the Pydantic model
parser = PydanticOutputParser(pydantic_object=CoTResponse)

# Prompt template with explicit zero-shot CoT cue ("Let's think step by step.")
prompt_template = ChatPromptTemplate.from_template(
"""
You are a step-by-step reasoning assistant.

Question: {question}

Answer: Let's think step by step, but only keep a minimum draft for
each thinking step, with 5 words at most.

Provide your solution in the following JSON format:
{format_instructions}

"""
)

# Inject the parser's format instructions into the template
prompt = prompt_template.partial(format_instructions=parser.get_format_instructions())

# Build the LCEL chain (prompt → model → parser)
chain = prompt | model | parser

# Example question and invocation
question = "A baker made 24 cookies. Half are chocolate chip. Half of those have sprinkles. How many chocolate-chip cookies with sprinkles?"

result = chain.invoke({"question": question})

# Display the result
print("\n--- Reasoning Chain ---\n", result.reasoning_chain)
print("\n--- Final Answer ---\n", result.answer)

SEO Example: Use CoD to create a list of ranking factors for a specific search engine algorithm update. Each short reasoning step becomes a concise, impactful point.

3. Chain-of-Translation Prompting

Concept: Translate a non-English input sentence into English before performing the task (e.g., sentiment analysis).

AI SEO Angle: Improves accuracy when dealing with non-English keywords or content ideas. Ensures the LLM understands the nuances of the topic before generating content.

# Define Final Structured Output Model
class TranslationSentiment(BaseModel):
telugu_sentence: str = Field(..., description="Original Telugu input")
english_translation: str = Field(..., description="English translation of the Telugu text")
sentiment_label: str = Field(..., description="Sentiment: Positive, Negative, or Neutral")

final_parser = PydanticOutputParser(pydantic_object=TranslationSentiment)

# Single Prompt Template (Translation + Classification)
prompt_template = ChatPromptTemplate.from_template(
"""
Consider yourself to be a human annotator who is well versed in English and Telugu language.
Given a Telugu sentence as input, perform the following tasks on the sentence:

1. Translate the given Telugu sentence into English.

2. Identify the sentiment depicted by the sentence.
If the sentence expresses a positive emotion or opinion, label it as Positive.
If the sentence expresses a negative emotion or complaint, label it as Negative.
If the sentence expresses neither positive nor negative sentiment, label it as Neutral.

3. Give the output as:
- the original Telugu sentence,
- its English translation,
- and the sentiment label.

Sentence is as follows:
{sentence}

Provide the final output using this JSON structure:
{format_instructions}
"""
)

single_prompt = prompt_template.partial(
format_instructions=final_parser.get_format_instructions()
)

# Build LCEL Chain (single LLM call)
chain = single_prompt | model | final_parser

# Run Chain of Translation Prompting on the Example
telugu_sentence = "సినిమా అద్భుతంగా ఉంది! డైరెక్టర్ పనితీరు సూపర్. మళ్ళీ చూడాలని ఉంది."

result = chain.invoke({"sentence": telugu_sentence})

print("\n--- FINAL OUTPUT ---\n")
print("Telugu Sentence       :", result.telugu_sentence)
print("English Translation   :", result.english_translation)
print("Sentiment Label       :", result.sentiment_label)

SEO Example: Research keywords in another language, translate them to English, and then use those translated keywords to generate English-language content.

4. Chain-of-Verification (CoVe) Prompting

Concept: Reduces factual errors (hallucinations) by forcing the LLM to verify its own answers before finalizing them.

AI SEO Angle: Crucial for creating trustworthy and authoritative content. Use CoVe when generating content about sensitive topics (e.g., finance, health, law) or when accuracy is paramount.

Multi-Stage Implementation: CoVe requires four distinct prompts and chains.

from typing import List

# ---------------------------------------------------------
# 2. Define structured outputs for all 4 CoVe stages
# ---------------------------------------------------------

class BaselineResponse(BaseModel):
draft_answer: str = Field(..., description="Initial unverified answer")

class VerificationPlan(BaseModel):
questions: List[str] = Field(..., description="List of verification questions generated from the draft")

class VerificationAnswers(BaseModel):
answers: List[str] = Field(..., description="Answers to the verification questions in the same order")

class FinalVerifiedResponse(BaseModel):
verified_answer: str = Field(..., description="Final corrected answer using only verified facts")

# ---------------------------------------------------------
# 3. Initialize the Gemini model (gemini-2.5-flash)
# ---------------------------------------------------------
model = init_chat_model(
"gemini-2.5-flash",
model_provider="google_genai",
temperature=0
)

# ---------------------------------------------------------
# 4. PROMPTS
# ---------------------------------------------------------

# 4.1 Baseline Draft Prompt
baseline_prompt_tmpl = ChatPromptTemplate.from_template(
"""
You are a factual answering assistant.

Step 1 of Chain-of-Verification:
Generate a baseline draft answer for the question. Do NOT verify anything yet.

Question:
{question}

Return your response in JSON:
{format_instructions}
"""
)

baseline_parser = PydanticOutputParser(pydantic_object=BaselineResponse)
baseline_prompt = baseline_prompt_tmpl.partial(format_instructions=baseline_parser.get_format_instructions())


# 4.2 Plan Verification Questions Prompt
verify_plan_tmpl = ChatPromptTemplate.from_template(
"""
You are now performing Step 2 of Chain-of-Verification.

Given the baseline draft answer below, generate verification questions to check EACH factual claim.

Draft Answer:
{draft}

Your job:
- Break the draft into factual claims.
- Create one verification question for each claim.
- Each question MUST be independently fact-checkable.

Return JSON:
{format_instructions}
"""
)

verify_plan_parser = PydanticOutputParser(pydantic_object=VerificationPlan)
verify_plan_prompt = verify_plan_tmpl.partial(format_instructions=verify_plan_parser.get_format_instructions())


# 4.3 Verification Answering Prompt
verify_answer_tmpl = ChatPromptTemplate.from_template(
"""
Step 3 of Chain-of-Verification.

Answer the following verification questions INDEPENDENTLY.
Do NOT refer to the draft answer. Use only factual knowledge.

Questions:
{questions}

Return JSON:
{format_instructions}
"""
)

verify_answer_parser = PydanticOutputParser(pydantic_object=VerificationAnswers)
verify_answer_prompt = verify_answer_tmpl.partial(format_instructions=verify_answer_parser.get_format_instructions())


# 4.4 Final Verified Response Prompt
final_answer_tmpl = ChatPromptTemplate.from_template(
"""
Step 4 of Chain-of-Verification.

You are given:
1. The baseline draft answer
2. The list of verification questions
3. The factual answers to those questions

Your task:
- Identify incorrect statements in the draft
- Keep only the claims supported by verification answers
- Remove or correct unsupported claims
- Produce the final VERIFIED answer

Draft:
{draft}

Verification Questions:
{questions}

Verification Answers:
{answers}

Return JSON:
{format_instructions}
"""
)

final_answer_parser = PydanticOutputParser(pydantic_object=FinalVerifiedResponse)
final_answer_prompt = final_answer_tmpl.partial(format_instructions=final_answer_parser.get_format_instructions())

# ---------------------------------------------------------
# 5. Build the LCEL chains
# ---------------------------------------------------------

baseline_chain = baseline_prompt | model | baseline_parser
time.sleep(1)
plan_chain = verify_plan_prompt | model | verify_plan_parser
time.sleep(1)
verify_chain = verify_answer_prompt | model | verify_answer_parser
time.sleep(1)
final_chain = final_answer_prompt | model | final_answer_parser

# ---------------------------------------------------------
# 6. Run CoVe on your example
# ---------------------------------------------------------

question = "Which US Presidents were born in the state of Texas?"

# Step 1: Baseline Draft
baseline = baseline_chain.invoke({"question": question})

# Step 2: Plan Verifications
plan = plan_chain.invoke({"draft": baseline.draft_answer})

# Step 3: Execute Verifications
verification = verify_chain.invoke({"questions": plan.questions})

# Step 4: Final Verified Answer
final = final_chain.invoke({
"draft": baseline.draft_answer,
"questions": plan.questions,
"answers": verification.answers
})

# ---------------------------------------------------------
# 7. Print all outputs
# ---------------------------------------------------------

print("\n--- Baseline Draft ---\n", baseline.draft_answer)
print("\n--- Verification Questions ---\n", plan.questions)
print("\n--- Verification Answers ---\n", verification.answers)
print("\n--- Final Verified Answer ---\n", final.verified_answer)

SEO Example: Generate a comprehensive guide about cryptocurrency investing using CoVe to ensure the information is accurate and up-to-date.

5. Least-to-Most Prompting (LtM)

Concept: Break a complex question into simpler sub-problems and solve them sequentially.

AI SEO Angle: Useful for creating long-form content that requires in-depth analysis and progressive explanation. Helps create tutorial-style content that guides users through a process step by step.

# Define structured output for LtM
class LtMResponse(BaseModel):
decomposition: str = Field(..., description="List of sub-problems in order")
sequential_solution: str = Field(..., description="Step-by-step solutions for each sub-problem")
final_answer: str = Field(..., description="Final numeric answer only")

# Create parser
parser = PydanticOutputParser(pydantic_object=LtMResponse)

# Zero-Shot Least-to-Most Prompt Template
prompt_template = ChatPromptTemplate.from_template(
"""
You are an expert reasoning assistant.

You must solve the problem using **Least-to-Most Prompting**, which has TWO required stages:

1. **Decomposition (Least):**
- Break the main problem into a sequential list of simpler sub-problems.

2. **Sequential Solving (Most):**
- Solve each sub-problem step-by-step.
- Use outputs of earlier sub-problems to solve later ones.
- Continue until the final answer is reached.

Question:
{question}

Provide your solution in the following JSON format:
{format_instructions}

Important:
- decomposition must contain numbered sub-problems.
- sequential_solution must show calculations for each sub-problem.
- final_answer must contain ONLY the final numeric answer.
"""
)

# Insert parser instructions
prompt = prompt_template.partial(format_instructions=parser.get_format_instructions())

# Build LCEL chain
chain = prompt | model | parser

# Invoke the chain using your marathon LtM problem
question = """
A runner is preparing for a marathon. She runs 10 miles every day.
Last week, she ran 7 days.
This week, she took a 2-day rest and ran 8 miles on the remaining days.
If she wants to run a total of 180 miles across both weeks,
how many more miles must she run in the next 3 days?
"""

result = chain.invoke({"question": question})

# Output
print(result)
print("\n--- Decomposition ---\n", result.decomposition)
print("\n--- Sequential Solution ---\n", result.sequential_solution)
print("\n--- Final Answer ---\n", result.final_answer)

SEO Example: Create a comprehensive guide to link building. Start with basic concepts (what is a link?), then progress to advanced strategies (guest posting, broken link building).

6. Plan-and-Solve Prompting

Concept: Guides the model to create a plan before solving the problem.

AI SEO Angle: Improves the logical flow and structure of content. Excellent for creating “how-to” guides, tutorials, and process documentation.

# Define structured output for Plan-and-Solve
class PlanSolveResponse(BaseModel):
variables: str = Field(..., description="Extracted relevant variables and their numerals")
plan: str = Field(..., description="A complete step-by-step plan to solve the problem")
calculation: str = Field(..., description="Execution of the plan with intermediate calculations")
final_answer: str = Field(..., description="Final numeric answer only")

# Create parser
parser = PydanticOutputParser(pydantic_object=PlanSolveResponse)

# Zero-Shot Plan-and-Solve Prompt Template
prompt_template = ChatPromptTemplate.from_template(
"""
You are an expert step-by-step reasoning assistant using plan and solve prompting following the instruction.
Let’s first understand the problem, extract relevant variables and their corresponding numerals, and make a complete plan.
Then, let’s carry out the plan, calculate intermediate variables (pay attention to correct numerical calculation and commonsense),
solve the problem step by step, and show the answer."

Question:
{question}

Answer:

Provide your solution in the following JSON format exactly:
{format_instructions}

Important:
- variables must list each extracted variable and its numeric value.
- plan must contain a numbered plan of steps to compute the answer.
- calculation must show the step-by-step execution of the plan with arithmetic.
- final_answer must contain ONLY the final numeric answer (no units, no explanation).
"""
)

# Insert parser instructions
prompt = prompt_template.partial(format_instructions=parser.get_format_instructions())

# Build LCEL chain
chain = prompt | model | parser

# Invoke the chain using your train-speed Plan-and-Solve problem
question = """
A train travels at an average speed of 60 mph for the first 3 hours of a journey and then at an average speed
of 40 mph for the remaining 2 hours. What is the average speed of the train for the entire journey?

Answer Choices: (A) 52 mph (B) 50 mph (C) 48 mph (D) 46 mph (E) 45 mph
"""

result = chain.invoke({"question": question})

# Output
print("\n--- Variables ---\n", result.variables)
print("\n--- Plan ---\n", result.plan)
print("\n--- Calculation ---\n", result.calculation)
print("\n--- Final Answer ---\n", result.final_answer)

SEO Example: Generate a detailed guide on conducting keyword research. The “plan” section outlines the steps (brainstorming, using keyword research tools, analyzing competitor keywords), and the “calculation” section provides specific examples.

7. Program-of-Thoughts (PoT) Prompting

Concept: The LLM generates executable Python code to solve the problem.

AI SEO Angle: Can be used to create interactive content or tools that demonstrate concepts. Useful for generating code snippets that solve specific problems (e.g., calculating ROI, optimizing images).

from langchain_experimental.utilities import PythonREPL  # UPDATED IMPORT

# Define PoT structured output
class PoTResponse(BaseModel):
program: str = Field(..., description="Python code that computes the answer. Must assign final result to 'ans'.")

# Parser
parser = PydanticOutputParser(pydantic_object=PoTResponse)

# Python Interpreter Tool (LangChain)
python_repl = PythonREPL()

# Zero-Shot PoT Prompt Template
prompt_template = ChatPromptTemplate.from_template(
"""
You are an expert numerical reasoning assistant.

You must solve the problem using **Program-of-Thoughts (PoT)** prompting.

Your output MUST be ONLY Python code:

- Use step-by-step reasoning expressed as variable assignments.
- Do NOT include comments.
- Do NOT include print statements.
- Use clear variable names.
- The last line MUST be: ans = <final value>
- The code MUST run in a Python interpreter.

Do NOT output natural language.
Do NOT add explanations.
ONLY return Python code.

Problem:
{question}

Provide the solution in this JSON format:
{format_instructions}
"""
)

# Insert parser instructions
prompt = prompt_template.partial(format_instructions=parser.get_format_instructions())

# Build chain
chain = prompt | model | parser

# Problem
question = """
Janet's ducks lay 16 eggs per day. She eats three for breakfast every morning and
bakes muffins for her friends every day with four. She sells the remainder at the
farmers' market daily for $2 per fresh duck egg. How much in dollars does she make
every day at the farmers' market?
"""

# Invoke LLM → get Python program
result = chain.invoke({"question": question})

print("\n--- Program Generated by LLM ---\n")
print(result.program)

# Execute using LangChain Python Interpreter Tool
execution_output = python_repl.run(result.program)

# Retrieve 'ans' from REPL environment
final_answer = python_repl.locals.get("ans", None)

print("\n--- Final Answer (from Python interpreter) ---\n")
print(final_answer)

SEO Example: Generate a Python script that analyzes website traffic data and identifies areas for improvement.

8. Rephrase-and-Respond Prompting

Concept: The LLM first rephrases the user’s question to remove ambiguity and clarify intent before answering it.

AI SEO Angle: Improves the relevance and accuracy of the generated content. Useful when dealing with complex or poorly worded prompts. Can help target specific user intents more effectively.

# Define Structured Output for Rephrase-and-Respond
class RaRResult(BaseModel):
rephrased_question: str = Field(..., description="The rephrased and expanded question")
response: str = Field(..., description="Final answer produced after rephrasing")

rar_parser = PydanticOutputParser(pydantic_object=RaRResult)

# Single-Prompt Rephrase-and-Respond Template
rar_prompt_template = ChatPromptTemplate.from_template(
"""
You are an expert reasoning assistant.

For the user question below, perform BOTH steps in a single reasoning flow:

1. Rephrase and expand the question
- Remove ambiguity
- State the hidden intention clearly
- Make the required reasoning explicit

2. Respond to the rephrased question
- Follow the clarified interpretation
- Provide a correct and well-reasoned answer

User Question:
{question}

Provide your output in this JSON format:
{format_instructions}
"""
)

rar_prompt = rar_prompt_template.partial(
format_instructions=rar_parser.get_format_instructions()
)

# Build the LCEL Chain — Only One LLM Call
rar_chain = rar_prompt | model | rar_parser

# Run RaR on the Example Question
question = "Identify the odd one out: Apple, Banana, Car, Orange."

result = rar_chain.invoke({"question": question})

print("\n--- REPHRASED QUESTION ---\n")
print(result.rephrased_question)

print("\n--- FINAL RESPONSE ---\n")
print(result.response)

SEO Example: If you provide a vague keyword like “SEO,” the LLM will rephrase it to something more specific like, “What are the top 5 strategies for improving organic search rankings in 2024?”. This ensures the content is focused on a particular user intent.

9. Self-Ask Prompting

Concept: The LLM breaks down a complex question into smaller follow-up questions and answers them sequentially.

AI SEO Angle: Improves the comprehensiveness and depth of content. Suitable for creating FAQs, troubleshooting guides, or complex explanations that require addressing multiple sub-questions.

# Define Pydantic schema
class SelfAskResponse(BaseModel):
reasoning_chain: str = Field(..., description="Complete self-ask transcript (follow-ups + intermediate answers)")
answer: str = Field(..., description="Final answer only in MM/DD/YYYY format")

# Create parser
parser = PydanticOutputParser(pydantic_object=SelfAskResponse)

# Few-shot Self-Ask example (1-shot)
few_shot_example = """
Q: The historical event was originally planned for 11/05/1852, but due to unexpected weather, it was moved forward by two days to today. What is the date 8 days from today in MM/DD/YYYY?
Are follow up questions needed here: Yes.
Follow up: What is today's date?
Intermediate answer: Moving an event forward by two days from 11/05/1852 means today's date is 11/03/1852.
Follow up: What date is 8 days from today?
Intermediate answer: 8 days from 11/03/1852 is 11/11/1852.
So the final answer is: 11/11/1852.
"""

# Prompt template matching your exact requested pattern
prompt_template = ChatPromptTemplate.from_template(
"""
You are a step-by-step reasoning assistant.

Here is an example problem solved using self-ask prompting:
{few_shot_example}

Now solve the following question using a similar self-ask prompting approach:

Question: {question}

Provide your solution in the following JSON format:
{format_instructions}
"""
)

# Inject reference example + parser formatting into the prompt
prompt = prompt_template.partial(
few_shot_example=few_shot_example,
format_instructions=parser.get_format_instructions()
)

# Build the LCEL chain
chain = prompt | model | parser

# Target Question (given earlier)
question = (
"A construction project started on 09/15/2024. The first phase took 12 days. "
"The second phase was originally scheduled for 20 days, but was shortened by 3 days. "
"What is the completion date of the second phase in MM/DD/YYYY?"
)

# Run the chain
result = chain.invoke({"question": question})

# Display result
print("\n--- Reasoning Chain (self-ask transcript) ---\n", result.reasoning_chain)
print("\n--- Final Answer ---\n", result.answer)

SEO Example: Use Self-Ask to create a comprehensive guide to a complex topic like “Technical SEO.” The LLM would ask itself sub-questions like: “What is crawling?”, “What is indexing?”, “What are the most common technical SEO errors?”.

10. Self-Consistency Prompting

Concept: Generate multiple reasoning chains and pick the most frequent answer.

AI SEO Angle: Improves the reliability of content. Reduces the likelihood of errors, especially in tasks involving calculations or factual information. Can be applied to various content types, but is particularly useful for generating lists or comparisons.

from collections import Counter

# Define structured output model
class SCResponse(BaseModel):
reasoning_chain: str = Field(..., description="Full reasoning steps")
answer: str = Field(..., description="Final numeric answer only")

# Create parser
parser = PydanticOutputParser(pydantic_object=SCResponse)

# Initialize Gemini model with sampling enabled
model = init_chat_model(
"gemini-2.5-flash",
model_provider="google_genai",
temperature=0.8,
top_k=40,
)

# Zero-shot Self-Consistency Prompt
prompt_template = ChatPromptTemplate.from_template(
"""
You are a step-by-step reasoning assistant.

Use deliberate, step-by-step reasoning.

Question: {question}

Instruction:
- Think through the problem step by step.
- Produce a full chain of thought.
- Then give ONLY the final numeric answer.

Return your output in this JSON format:
{format_instructions}

Important:
- reasoning_chain must contain multiple reasoning steps.
- answer must contain ONLY the final numeric answer.
"""
)

prompt = prompt_template.partial(format_instructions=parser.get_format_instructions())

# Build LCEL chain
chain = prompt | model | parser

# Self-Consistency Sampling (with sleep + 5 samples)
def self_consistency(question: str, samples: int = 5):
answers = []
all_outputs = []

for i in range(samples):
result = chain.invoke({"question": question})
answers.append(result.answer)
all_outputs.append(result)

time.sleep(1)   # <-- prevents rate-limits

final_answer = Counter(answers).most_common(1)[0][0]
return final_answer, all_outputs

#Run on your example
question = (
"When I was 6 years old, my sister was half my age. Now I am 70 years old. How old is my sister?"
)

final_answer, outputs = self_consistency(question, samples=5)

#Display results
print("\n===== SELF CONSISTENCY OUTPUT =====")
print("Final Aggregated Answer:", final_answer)

print("\n===== ALL SAMPLED REASONING PATHS =====")
for i, out in enumerate(outputs, 1):
print(f"\n--- Sample {i} ---")
print(out.reasoning_chain)
print("Answer:", out.answer)

SEO Example: Generate multiple product descriptions for an e-commerce site and select the one that best highlights the key selling points based on a consistent theme.

11. Step-Back Prompting

Concept: Guide the LLM to identify the high-level concept or first principle before solving the task.

AI SEO Angle: Helps create content that demonstrates a deep understanding of the topic. Use Step-Back to generate thought leadership pieces or content that explains complex concepts in a simplified way.

# Define Structured Output Models
class Abstraction(BaseModel):
stepback_question: str = Field(..., description="The abstract step-back question")
stepback_answer: str = Field(..., description="The high-level principle that answers the step-back question")

class FinalAnswer(BaseModel):
final_answer: str = Field(..., description="The final solution using the abstract principle")

abstraction_parser = PydanticOutputParser(pydantic_object=Abstraction)
final_answer_parser = PydanticOutputParser(pydantic_object=FinalAnswer)

# Prompt Templates (ONLY TWO CALLS)

# --- Call 1: Step-Back Abstraction ---
abstraction_prompt_template = ChatPromptTemplate.from_template(
"""
You are an expert in abstraction.

Given the original q