"""
Pattern 194: Chain Prompting Pattern
Breaks complex tasks into a sequence of simpler prompts where each
prompt builds on previous outputs. Creates dependency chain of prompts.
"""
from typing import Dict, Any, List, Optional
from dataclasses import dataclass, field
from datetime import datetime
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
@dataclass
class PromptStep:
"""Single step in prompt chain."""
name: str
prompt_template: str
depends_on: List[str] = field(default_factory=list)
output: Optional[str] = None
timestamp: Optional[datetime] = None
@dataclass
class ChainExecution:
"""Execution trace of prompt chain."""
steps: List[PromptStep]
inputs: Dict[str, Any]
outputs: Dict[str, str]
execution_order: List[str]
total_time: float = 0.0
class ChainPromptingAgent:
"""Agent that executes prompt chains."""
def __init__(self, name: str, model_name: str = "gpt-4"):
self.name = name
self.llm = ChatOpenAI(model=model_name, temperature=0.7)
self.steps: Dict[str, PromptStep] = {}
self.executions: List[ChainExecution] = []
def add_step(self, step: PromptStep):
"""Add step to chain."""
self.steps[step.name] = step
print(f" Added step: {step.name}")
def _resolve_dependencies(self) -> List[str]:
"""Resolve execution order based on dependencies."""
executed = set()
execution_order = []
def can_execute(step_name: str) -> bool:
step = self.steps[step_name]
return all(dep in executed for dep in step.depends_on)
while len(executed) ChainExecution:
"""Execute the prompt chain."""
print(f"\n {self.name}: Executing prompt chain...")
start_time = datetime.now()
# Resolve execution order
execution_order = self._resolve_dependencies()
print(f" Execution order: {' → '.join(execution_order)}")
# Execute steps in order
outputs = {}
executed_steps = []
for step_name in execution_order:
step = self.steps[step_name]
print(f"\n Executing: {step_name}")
# Prepare input by gathering dependencies
step_input = initial_input.copy()
for dep in step.depends_on:
if dep in outputs:
step_input[dep] = outputs[dep]
# Execute step
prompt = ChatPromptTemplate.from_messages([
("system", "You are part of a multi-step reasoning chain."),
("human", step.prompt_template)
])
chain = prompt | self.llm
response = chain.invoke(step_input)
output = response.content
outputs[step_name] = output
step.output = output
step.timestamp = datetime.now()
executed_steps.append(step)
print(f" Output: {output[:100]}...")
end_time = datetime.now()
execution = ChainExecution(
steps=executed_steps,
inputs=initial_input,
outputs=outputs,
execution_order=execution_order,
total_time=(end_time - start_time).total_seconds()
)
self.executions.append(execution)
return execution
class ChainPromptingPattern:
"""
Chain Prompting Pattern - Sequential prompt dependencies.
Breaks complex tasks into dependent steps where each step
uses outputs from previous steps.
"""
def __init__(self):
self.agents: Dict[str, ChainPromptingAgent] = {}
def register_agent(self, agent: ChainPromptingAgent):
"""Register chain prompting agent."""
self.agents[agent.name] = agent
def run(self, initial_inputs: Dict[str, Any]) -> Dict[str, Any]:
"""Execute prompt chains."""
print("=== Chain Prompting Pattern ===\n")
results = {}
for agent in self.agents.values():
execution = agent.execute_chain(initial_inputs)
results[agent.name] = execution.outputs
return {
"pattern": "ChainPrompting",
"agents": len(self.agents),
"results": results,
"total_steps": sum(len(a.steps) for a in self.agents.values())
}
# Example usage
if __name__ == "__main__":
print("=== Chain Prompting Pattern Demo ===\n")
# Create pattern and agent
pattern = ChainPromptingPattern()
agent = ChainPromptingAgent("ArticleWriter")
# Build prompt chain for article writing
print("1. Building prompt chain...\n")
# Step 1: Research (no dependencies)
agent.add_step(PromptStep(
name="research",
prompt_template="Research key facts about: {topic}. List 5 important facts.",
depends_on=[]
))
# Step 2: Outline (depends on research)
agent.add_step(PromptStep(
name="outline",
prompt_template="Create an article outline about {topic} using these facts:\n{research}",
depends_on=["research"]
))
# Step 3: Introduction (depends on outline)
agent.add_step(PromptStep(
name="introduction",
prompt_template="Write an engaging introduction for this article:\nTopic: {topic}\nOutline: {outline}",
depends_on=["outline"]
))
# Step 4: Body (depends on outline and research)
agent.add_step(PromptStep(
name="body",
prompt_template="Write the main body using:\nOutline: {outline}\nFacts: {research}",
depends_on=["outline", "research"]
))
# Step 5: Conclusion (depends on all previous)
agent.add_step(PromptStep(
name="conclusion",
prompt_template="Write a conclusion that ties together:\nIntro: {introduction}\nBody: {body}",
depends_on=["introduction", "body"]
))
pattern.register_agent(agent)
# Execute chain
print("\n2. Executing chain...\n")
summary = pattern.run({"topic": "Artificial Intelligence in Healthcare"})
print(f"\n3. Summary:")
print(f" Total steps: {summary['total_steps']}")
print(f" Steps executed: {len(agent.executions[0].execution_order)}")
print(f"\n4. Chain Outputs:")
for step_name, output in agent.executions[0].outputs.items():
print(f"\n {step_name}:")
print(f" {output[:150]}...")
print(f"\n Total execution time: {agent.executions[0].total_time:.2f}s")
print("\n✓ Chain prompting: sequential dependent prompts!")
Agentic Architecture Pattern: Chain Prompting
Pattern 194: 194 Chain Prompting Pattern – Line-by-Line Explanation
Overview
Pattern 194: Chain Prompting Pattern
Breaks complex tasks into a sequence of simpler prompts where each prompt builds on previous outputs. Creates dependency chain of prompts.
Code Structure Analysis
File Information
- Pattern Number: 194
- Pattern Name: 194 Chain Prompting Pattern
- File Path:
patterns\llm_specific\194_chain_prompting_pattern.py - Total Lines: 221
Detailed Code Explanation
Module Docstring
"""
Pattern 194: Chain Prompting Pattern
Breaks complex tasks into a sequence of simpler prompts where each
prompt builds on previous outputs. Creates dependency chain of prompts.
"""
Explanation: This module docstring describes the purpose and key features of the 194 Chain Prompting Pattern pattern.
Imports Section
from typing import Dict, Any, List, Optional
from dataclasses import dataclass, field
from datetime import datetime
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI # First 20 imports shown
Explanation: The module imports necessary dependencies:
– from typing import Dict, Any, List, Optional: Type hints for better code documentation
– from dataclasses import dataclass, field: Data class decorators for clean data structures
– from datetime import datetime: Date and time utilities
– from langchain_core.prompts import ChatPromptTemplate: LangChain framework integration
– from langchain_openai import ChatOpenAI: LangChain framework integration
Classes
PromptStep (Line 16)
Description: Single step in prompt chain.
ChainExecution (Line 26)
Description: Execution trace of prompt chain.
ChainPromptingAgent (Line 35)
Description: Agent that executes prompt chains.
Methods:
__init__ (Line 38)
def __init__(self, name, model_name):
"""No method docstring."""
Purpose: No method docstring.
Parameters:
– self: Instance reference
– name: Identifier or label
– model_name: LLM model to use (e.g., “gpt-4”)
add_step (Line 44)
def add_step(self, step):
"""Add step to chain."""
Purpose: Add step to chain.
Parameters:
– self: Instance reference
– step: Parameter for step
_resolve_dependencies (Line 49)
def _resolve_dependencies(self):
"""Resolve execution order based on dependencies."""
Purpose: Resolve execution order based on dependencies.
Parameters:
– self: Instance reference
execute_chain (Line 71)
def execute_chain(self, initial_input):
"""Execute the prompt chain."""
Purpose: Execute the prompt chain.
Parameters:
– self: Instance reference
– initial_input: Parameter for initial_input
ChainPromptingPattern (Line 125)
Description: Chain Prompting Pattern – Sequential prompt dependencies.
Breaks complex tasks into dependent steps where each step uses outputs from previous steps.
Methods:
__init__ (Line 133)
def __init__(self):
"""No method docstring."""
Purpose: No method docstring.
Parameters:
– self: Instance reference
register_agent (Line 136)
def register_agent(self, agent):
"""Register chain prompting agent."""
Purpose: Register chain prompting agent.
Parameters:
– self: Instance reference
– agent: Parameter for agent
run (Line 140)
def run(self, initial_inputs):
"""Execute prompt chains."""
Purpose: Execute prompt chains.
Parameters:
– self: Instance reference
– initial_inputs: Parameter for initial_inputs
Design Patterns Used
- Strategy Pattern: Different execution strategies for various scenarios
- State Pattern: Managing different states in the workflow
- Chain of Responsibility: Sequential processing through workflow nodes
- Observer Pattern: Tracking and monitoring pattern execution
- Factory Pattern: Creating instances with proper configuration
Usage Example
# Initialize the pattern
pattern = PromptStep(name="example", model_name="gpt-4")
# Configure and execute
result = pattern.execute(data={"key": "value"})
# Check results
print(result)
Key Concepts
- LLM Integration: Uses LangChain/OpenAI for intelligent decision-making
- Workflow Orchestration: LangGraph manages execution flow through nodes
- State Management: TypedDict defines workflow state structure
- Error Handling: Comprehensive error handling and fallback mechanisms
- Extensibility: Designed for easy customization and extension
Extension Points
This pattern can be extended by: 1. Adding custom workflow nodes 2. Implementing additional validation logic 3. Integrating with external services 4. Customizing LLM prompts and responses 5. Adding monitoring and logging capabilities