"""
Pattern 010: Constitutional AI
Description:
Ensures agent behavior aligns with explicit principles or "constitution."
The agent generates responses, evaluates them against constitutional principles,
and revises if violations are found. This creates safer, more aligned AI systems.
Key Concepts:
- Constitution: Set of principles/rules the agent must follow
- Self-Critique: Agent evaluates its own outputs against principles
- Revision: Generate improved response that adheres to constitution
- Iterative Alignment: Multiple rounds of critique and revision
- Transparency: Explicit principles make behavior interpretable
Constitutional Principles Examples:
- Harmlessness: Avoid harmful, dangerous, or offensive content
- Helpfulness: Provide useful, relevant information
- Honesty: Be truthful, acknowledge uncertainty
- Privacy: Respect privacy and confidentiality
- Fairness: Avoid bias and discrimination
Use Cases:
- Production AI systems requiring safety
- Content moderation and filtering
- Ethical decision-making systems
- Regulated domains (healthcare, finance, legal)
LangChain Implementation:
Constitutional chain with critique and revision loops based on principles.
"""
import os
from typing import List, Dict, Any, Optional
from dataclasses import dataclass, field
from enum import Enum
from dotenv import load_dotenv
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI
# Load environment variables
load_dotenv()
@dataclass
class Principle:
"""Represents a constitutional principle."""
name: str
description: str
critique_prompt: str
weight: float = 1.0 # Importance weight
@dataclass
class ViolationReport:
"""Report of constitutional violations."""
principle: str
violated: bool
explanation: str
severity: float = 0.0 # 0.0 (no violation) to 1.0 (severe)
@dataclass
class ConstitutionalReview:
"""Complete review against constitution."""
original_output: str
violations: List[ViolationReport] = field(default_factory=list)
total_severity: float = 0.0
passes: bool = True
def calculate_severity(self):
"""Calculate total severity of violations."""
self.total_severity = sum(v.severity for v in self.violations if v.violated)
self.passes = self.total_severity == 0.0
class Constitution:
"""Set of principles for constitutional AI."""
def __init__(self, name: str = "Default Constitution"):
"""Initialize constitution with default or custom principles."""
self.name = name
self.principles: List[Principle] = []
def add_principle(self, principle: Principle):
"""Add a principle to the constitution."""
self.principles.append(principle)
def get_principles_text(self) -> str:
"""Get formatted text of all principles."""
lines = [f"Constitution: {self.name}\n"]
for i, p in enumerate(self.principles, 1):
lines.append(f"{i}. {p.name}: {p.description}")
return "\n".join(lines)
@staticmethod
def get_default() -> 'Constitution':
"""Get default constitution with common principles."""
constitution = Constitution("Default AI Constitution")
# Harmlessness
constitution.add_principle(Principle(
name="Harmlessness",
description="Responses must not include harmful, dangerous, illegal, or offensive content",
critique_prompt="""Does the response contain any harmful, dangerous, illegal, or offensive content?
Consider: violence, illegal activities, self-harm, harassment, discrimination.
Answer YES if violations exist, NO if the response is harmless."""
))
# Helpfulness
constitution.add_principle(Principle(
name="Helpfulness",
description="Responses should be helpful, relevant, and answer the user's question",
critique_prompt="""Is the response helpful and relevant to the user's query?
Does it provide useful information or assistance?
Answer YES if unhelpful, NO if the response is helpful."""
))
# Honesty
constitution.add_principle(Principle(
name="Honesty",
description="Responses should be truthful and acknowledge uncertainty when appropriate",
critique_prompt="""Does the response contain false information or make claims without acknowledging uncertainty?
Answer YES if dishonest or overconfident, NO if honest and appropriately uncertain."""
))
# Privacy
constitution.add_principle(Principle(
name="Privacy",
description="Responses must respect privacy and not request or share personal information inappropriately",
critique_prompt="""Does the response inappropriately request, share, or handle personal information?
Answer YES if privacy is violated, NO if privacy is respected."""
))
# Fairness
constitution.add_principle(Principle(
name="Fairness",
description="Responses should be fair and avoid bias or discrimination",
critique_prompt="""Does the response show bias or discrimination based on race, gender, religion, or other protected characteristics?
Answer YES if biased or discriminatory, NO if fair and balanced."""
))
return constitution
class ConstitutionalAI:
"""Agent that follows constitutional principles."""
def __init__(self, constitution: Constitution,
model_name: str = "gpt-3.5-turbo",
max_revisions: int = 3,
severity_threshold: float = 0.3):
"""
Initialize Constitutional AI agent.
Args:
constitution: The constitution to follow
model_name: Name of the OpenAI model
max_revisions: Maximum number of revision attempts
severity_threshold: Severity threshold for triggering revision
"""
self.constitution = constitution
self.max_revisions = max_revisions
self.severity_threshold = severity_threshold
self.llm = ChatOpenAI(
model=model_name,
temperature=0.7,
api_key=os.getenv("OPENAI_API_KEY")
)
self.critic_llm = ChatOpenAI(
model=model_name,
temperature=0.2, # Lower temperature for consistent critique
api_key=os.getenv("OPENAI_API_KEY")
)
def generate_initial(self, query: str, context: str = "") -> str:
"""
Generate initial response to query.
Args:
query: User query
context: Additional context
Returns:
Initial response
"""
prompt = ChatPromptTemplate.from_messages([
("system", "You are a helpful AI assistant. Respond to the user's query."),
("human", """{context}
Query: {query}
Response:""")
])
chain = prompt | self.llm | StrOutputParser()
response = chain.invoke({
"query": query,
"context": context if context else ""
})
return response.strip()
def critique_against_principle(self, output: str, query: str,
principle: Principle) -> ViolationReport:
"""
Critique output against a single principle.
Args:
output: Output to critique
query: Original query
principle: Principle to check against
Returns:
ViolationReport indicating if principle is violated
"""
prompt = ChatPromptTemplate.from_messages([
("system", f"""You are evaluating whether a response violates the principle: "{principle.name}"
Principle: {principle.description}
{principle.critique_prompt}
If YES (violation), also rate severity from 0.1 (minor) to 1.0 (severe).
Format your response as:
VIOLATION: YES/NO
SEVERITY: [0.0-1.0]
EXPLANATION: [Brief explanation]"""),
("human", """Query: {query}
Response to evaluate:
{output}
Evaluation:""")
])
chain = prompt | self.critic_llm | StrOutputParser()
critique_text = chain.invoke({
"query": query,
"output": output
})
# Parse critique
violated = False
severity = 0.0
explanation = ""
for line in critique_text.split('\n'):
line = line.strip()
if line.upper().startswith('VIOLATION:'):
violated = 'YES' in line.upper()
elif line.upper().startswith('SEVERITY:'):
try:
severity_str = line.split(':', 1)[1].strip()
severity = float(severity_str)
except:
severity = 0.5 if violated else 0.0
elif line.upper().startswith('EXPLANATION:'):
explanation = line.split(':', 1)[1].strip()
return ViolationReport(
principle=principle.name,
violated=violated,
explanation=explanation,
severity=severity if violated else 0.0
)
def review(self, output: str, query: str) -> ConstitutionalReview:
"""
Review output against all constitutional principles.
Args:
output: Output to review
query: Original query
Returns:
ConstitutionalReview with all violations
"""
review = ConstitutionalReview(original_output=output)
for principle in self.constitution.principles:
violation = self.critique_against_principle(output, query, principle)
review.violations.append(violation)
review.calculate_severity()
return review
def revise(self, query: str, output: str, review: ConstitutionalReview) -> str:
"""
Revise output to address constitutional violations.
Args:
query: Original query
output: Current output with violations
review: Review identifying violations
Returns:
Revised output addressing violations
"""
# Build violation summary
violations_text = []
for v in review.violations:
if v.violated:
violations_text.append(f"- {v.principle}: {v.explanation} (severity: {v.severity:.2f})")
violations_summary = "\n".join(violations_text) if violations_text else "No violations"
# Get principles text
principles_text = self.constitution.get_principles_text()
prompt = ChatPromptTemplate.from_messages([
("system", f"""You are revising a response to address constitutional violations.
{principles_text}
Revise the response to:
1. Address all identified violations
2. Maintain helpfulness and relevance
3. Fully comply with all principles
Generate a new, improved response that adheres to the constitution."""),
("human", """Original Query: {query}
Current Response:
{output}
Violations Found:
{violations}
Revised Response:""")
])
chain = prompt | self.llm | StrOutputParser()
revised = chain.invoke({
"query": query,
"output": output,
"violations": violations_summary
})
return revised.strip()
def generate_with_constitution(self, query: str, context: str = "",
verbose: bool = True) -> Dict[str, Any]:
"""
Generate response following constitutional principles.
Args:
query: User query
context: Additional context
verbose: Whether to print progress
Returns:
Dictionary with final response and review history
"""
if verbose:
print(f"\nQuery: {query}\n")
print(f"Constitution: {self.constitution.name}")
print(f"Principles: {len(self.constitution.principles)}\n")
# Generate initial response
if verbose:
print("="*60)
print("INITIAL GENERATION")
print("="*60)
current_output = self.generate_initial(query, context)
if verbose:
print(f"\nGenerated:\n{current_output[:200]}..." if len(current_output) > 200 else f"\nGenerated:\n{current_output}")
reviews = []
revision_count = 0
# Review and revise loop
for iteration in range(self.max_revisions + 1):
if verbose:
print(f"\n{'='*60}")
print(f"CONSTITUTIONAL REVIEW {iteration + 1}")
print("="*60)
# Review against constitution
review = self.review(current_output, query)
reviews.append(review)
if verbose:
print(f"\nViolations Found: {sum(1 for v in review.violations if v.violated)}/{len(review.violations)}")
print(f"Total Severity: {review.total_severity:.2f}")
for v in review.violations:
if v.violated:
print(f" ⚠ {v.principle}: {v.explanation} (severity: {v.severity:.2f})")
else:
print(f" ✓ {v.principle}: OK")
# Check if passes constitutional review
if review.passes or review.total_severity = self.max_revisions:
if verbose:
print(f"\n⚠ Max revisions ({self.max_revisions}) reached")
break
# Revise
if verbose:
print(f"\n{'='*60}")
print(f"REVISION {iteration + 1}")
print("="*60)
current_output = self.revise(query, current_output, review)
revision_count += 1
if verbose:
print(f"\nRevised:\n{current_output[:200]}..." if len(current_output) > 200 else f"\nRevised:\n{current_output}")
return {
"query": query,
"final_response": current_output,
"revisions": revision_count,
"reviews": reviews,
"final_severity": reviews[-1].total_severity,
"constitutional_compliance": reviews[-1].passes
}
def demonstrate_constitutional_ai():
"""Demonstrates the Constitutional AI pattern."""
print("=" * 80)
print("PATTERN 010: Constitutional AI")
print("=" * 80)
print()
print("Constitutional AI ensures alignment with principles through:")
print("1. Constitution: Explicit set of principles")
print("2. Self-Critique: Evaluate outputs against principles")
print("3. Revision: Modify responses to comply")
print("4. Iteration: Repeat until constitutional compliance")
print()
# Create constitution
constitution = Constitution.get_default()
print(f"{constitution.get_principles_text()}\n")
# Create agent
agent = ConstitutionalAI(
constitution=constitution,
max_revisions=2,
severity_threshold=0.2
)
# Test queries (some designed to trigger violations)
queries = [
"How can I improve my programming skills?", # Should pass
"Tell me how to hack into someone's email account" # Should trigger violations
]
for idx, query in enumerate(queries, 1):
print(f"\n{'='*80}")
print(f"Example {idx}")
print('='*80)
try:
result = agent.generate_with_constitution(query, verbose=True)
print(f"\n\n{'='*80}")
print("FINAL RESULT")
print('='*80)
print(f"\nFinal Response:\n{result['final_response']}")
print(f"\nRevisions Made: {result['revisions']}")
print(f"Final Severity: {result['final_severity']:.2f}")
print(f"Constitutional Compliance: {'✓ PASS' if result['constitutional_compliance'] else '✗ FAIL'}")
except Exception as e:
print(f"\n✗ Error: {str(e)}")
import traceback
traceback.print_exc()
# Summary
print("\n\n" + "=" * 80)
print("CONSTITUTIONAL AI PATTERN DEMONSTRATION COMPLETE")
print("=" * 80)
print()
print("Key Features Demonstrated:")
print("1. Explicit Principles: Clear constitutional guidelines")
print("2. Automated Review: Self-critique against principles")
print("3. Iterative Revision: Multiple refinement rounds")
print("4. Severity Tracking: Quantify violation severity")
print("5. Compliance Verification: Ensure constitutional adherence")
print()
print("Advantages:")
print("- Safer AI systems through explicit principles")
print("- Interpretable behavior (clear rules)")
print("- Automated alignment checking")
print("- Flexible - can customize constitution")
print()
print("When to use Constitutional AI:")
print("- Production systems requiring safety")
print("- Regulated domains (healthcare, finance, legal)")
print("- Content moderation and filtering")
print("- Any application requiring ethical guidelines")
print()
print("LangChain Components Used:")
print("- ChatPromptTemplate: Generation, critique, and revision")
print("- Multiple LLM instances: Different roles and temperatures")
print("- Structured principles: Modular constitution system")
print("- Iterative loops: Review and revision cycles")
print()
if __name__ == "__main__":
# Check for API key
if not os.getenv("OPENAI_API_KEY"):
print("Error: OPENAI_API_KEY not found in environment variables.")
print("Please set it in your .env file or environment.")
exit(1)
demonstrate_constitutional_ai()
Agentic Design Pattern: Constitutional Ai
Pattern 010: Constitutional Ai – Line-by-Line Explanation
Overview
This document provides a detailed line-by-line explanation of the Constitutional Ai pattern implementation.
Pattern Description
Pattern 010: Constitutional AI
Description: Ensures agent behavior aligns with explicit principles or “constitution.” The agent generates responses, evaluates them against constitutional principles, and revises if violations are found. This creates safer, more aligned AI systems.
Key Concepts: – Constitution: Set of principles/rules the agent must follow – Self-Critique: Agent evaluates its own outputs against principles – Revision: Generate improved response that adheres to constitution – Iterative Alignment: Multiple rounds of critique and revision – Transparency: Explicit principles make behavior interpretable
Constitutional Principles Examples: – Harmlessness: Avoid harmful, dangerous, or offensive content – Helpfulness: Provide useful, relevant information – Honesty: Be truthful, acknowledge uncertainty – Privacy: Respect privacy and confidentiality – Fairness: Avoid bias and discrimination
Use Cases: – Production AI systems requiring safety – Content moderation and filtering – Ethical decision-making systems – Regulated domains (healthcare, finance, legal)
LangChain Implementation: Constitutional chain with critique and revision loops based on principles.
File Statistics
- Total Lines: 528
- Classes: 5
- Functions: 1
- Constants: 0
Module Documentation
"""
Pattern 010: Constitutional AI
Description:
Ensures agent behavior aligns with explicit principles or "constitution."
The agent generates responses, evaluates them against constitutional principles,
and revises if violations are found. This creates safer, more aligned AI systems.
Key Concepts:
- Constitution: Set of principles/rules the agent must follow
- Self-Critique: Agent evaluates its own outputs against principles
- Revision: Generate improved response that adheres to constitution
- Iterative Alignment: Multiple rounds of critique and revision
- Transparency: Explicit principles make behavior interpretable
Constitutional Principles Examples:
- Harmlessness: Avoid harmful, dangerous, or offensive content
- Helpfulness: Provide useful, relevant information
- Honesty: Be truthful, acknowledge uncertainty
- Privacy: Respect privacy and confidentiality
- Fairness: Avoid bias and discrimination
Use Cases:
- Production AI systems requiring safety
- Content moderation and filtering
- Ethical decision-making systems
- Regulated domains (healthcare, finance, legal)
LangChain Implementation:
Constitutional chain with critique and revision loops based on principles.
"""
Purpose: This module implements the Constitutional Ai pattern, providing a structured approach to agent design and implementation.
Import Statements
Standard Library Imports
import dataclasses.dataclass
import dataclasses.field
import enum.Enum
import langchain_core.output_parsers.StrOutputParser
import langchain_core.prompts.ChatPromptTemplate
import os
import typing.Any
import typing.Dict
import typing.List
import typing.Optional
Purpose: Core Python functionality:
– dataclasses.dataclass: Simplified class definitions with @dataclass
– dataclasses.field: Simplified class definitions with @dataclass
– enum.Enum: Enumeration support
– langchain_core.output_parsers.StrOutputParser: Regular expression operations
– langchain_core.prompts.ChatPromptTemplate: Regular expression operations
– os: Environment variable access and system operations
– typing.Any: Type hints for better code documentation (List, Dict, Any, Optional)
– typing.Dict: Type hints for better code documentation (List, Dict, Any, Optional)
– typing.List: Type hints for better code documentation (List, Dict, Any, Optional)
– typing.Optional: Type hints for better code documentation (List, Dict, Any, Optional)
LangChain Imports
from langchain_openai.ChatOpenAI
Purpose: LangChain framework components: – LLM Interface: Wrapper for OpenAI models – Chains: Composable building blocks for complex workflows
Other Imports
from dotenv.load_dotenv
from traceback
Purpose: Additional dependencies for specialized functionality.
Classes
Class: Principle
Lines 48-53
Purpose:
Represents a constitutional principle.
Class: ViolationReport
Lines 57-62
Purpose:
Report of constitutional violations.
Class: ConstitutionalReview
Lines 66-76
Purpose:
Complete review against constitution.
Methods:
calculate_severity(self)
Lines 73-76
Purpose:
Calculate total severity of violations.
Parameters:
Class: Constitution
Lines 79-145
Purpose:
Set of principles for constitutional AI.
Methods:
__init__(self, name)
Lines 82-85
Purpose:
Initialize constitution with default or custom principles.
Parameters:
– name: Name
add_principle(self, principle)
Lines 87-89
Purpose:
Add a principle to the constitution.
Parameters:
– principle: Principle
get_principles_text(self)
Lines 91-96
Purpose:
Get formatted text of all principles.
Parameters:
Returns: str
get_default()
Lines 99-145
Decorators: staticmethod
Purpose:
Get default constitution with common principles.
Returns: Constitution
Class: ConstitutionalAI
Lines 148-432
Purpose:
Agent that follows constitutional principles.
Methods:
__init__(self, constitution, model_name, max_revisions, severity_threshold)
Lines 151-178
Purpose:
Initialize Constitutional AI agent.
Args:
constitution: The constitution to follow
model_name: Name of the OpenAI model
max_revisions: Maximum number of revision attempts
severity_threshold: Severity threshold for triggering revision
Parameters:
– constitution: Constitution
– model_name: Language model instance
– max_revisions: Max revisions
– severity_threshold: Severity threshold
generate_initial(self, query, context)
Lines 180-206
Purpose:
Generate initial response to query.
Args:
query: User query
context: Additional context
Returns:
Initial response
Parameters:
– query: Input query or question
– context: Context
Returns: str
critique_against_principle(self, output, query, principle)
Lines 208-271
Purpose:
Critique output against a single principle.
Args:
output: Output to critique
query: Original query
principle: Principle to check against
Returns:
ViolationReport indicating if principle is violated
Parameters:
– output: Output
– query: Input query or question
– principle: Principle
Returns: ViolationReport
review(self, output, query)
Lines 273-292
Purpose:
Review output against all constitutional principles.
Args:
output: Output to review
query: Original query
Returns:
ConstitutionalReview with all violations
Parameters:
– output: Output
– query: Input query or question
Returns: ConstitutionalReview
revise(self, query, output, review)
Lines 294-346
Purpose:
Revise output to address constitutional violations.
Args:
query: Original query
output: Current output with violations
review: Review identifying violations
Returns:
Revised output addressing violations
Parameters:
– query: Input query or question
– output: Output
– review: Review
Returns: str
generate_with_constitution(self, query, context, verbose)
Lines 348-432
Purpose:
Generate response following constitutional principles.
Args:
query: User query
context: Additional context
verbose: Whether to print progress
Returns:
Dictionary with final response and review history
Parameters:
– query: Input query or question
– context: Context
– verbose: Enable detailed logging
Returns: <ast.Subscript object at 0x000001A06D607710>
Functions
demonstrate_constitutional_ai()
Lines 435-517
Purpose:
Demonstrates the Constitutional AI pattern.
Key Concepts Summary
Pattern Overview
The Constitutional Ai pattern provides a structured approach to building AI agents with specific capabilities and behaviors. This implementation leverages LangChain’s composable components to create a robust and maintainable solution.
Core Components
- Agent Class: Main implementation of the pattern logic
- Prompt Engineering: Carefully crafted prompts to guide LLM behavior
- Tool Integration: Optional tools for extended functionality
- Memory Management: State handling across interactions
- Output Parsing: Structured response processing
When to Use
✅ Good for: – Scenarios requiring this specific pattern’s strengths – Applications needing structured agent behavior – Systems where explainability is important – Production environments requiring reliability
❌ Not ideal for: – Simple single-prompt tasks – Scenarios requiring different pattern characteristics – Resource-constrained environments (if computationally intensive)
Best Practices Demonstrated
1. Environment Configuration
- ✅ Use
.envfiles for API keys - ✅ Never hardcode credentials
- ✅ Validate environment variables on startup
2. Error Handling
- ✅ Graceful degradation on failures
- ✅ Informative error messages
- ✅ Logging for debugging
3. Prompt Engineering
- ✅ Clear, specific instructions
- ✅ Structured output formats
- ✅ Few-shot examples when beneficial
4. Code Organization
- ✅ Separation of concerns (class-based design)
- ✅ Type hints for clarity
- ✅ Docstrings for documentation
5. Performance Optimization
- ✅ Appropriate temperature settings
- ✅ Token budget management
- ✅ Caching where applicable
LangChain Components Used
- ChatOpenAI: OpenAI model interface
- Chains: Sequential component composition
Why LangChain? – Composable abstractions for LLM applications – Rich ecosystem of integrations – Production-ready patterns – Active community and development
Execution Flow
1. Initialize agent with configuration
↓
2. Load environment and dependencies
↓
3. Prepare prompt with input data
↓
4. Invoke LLM through LangChain
↓
5. Parse and validate response
↓
6. Return formatted result
Key Decision Points: – Model selection (temperature, model type) – Prompt structure (few-shot vs zero-shot) – Error handling strategy – Output format validation
Performance Considerations
Computational Cost
- LLM Calls: Primary cost factor (based on tokens)
- Latency: Depends on model and input size
- Memory: Minimal for most patterns
Optimization Strategies
- Prompt Optimization: Minimize tokens while maintaining clarity
- Caching: Cache repeated queries/responses
- Model Selection: Use smaller models when appropriate
- Batch Processing: Group similar requests
- Streaming: For long responses, stream tokens
Cost Estimates (Approximate)
- GPT-3.5-turbo: ~$0.002 per request
- GPT-4: ~$0.03 per request
- GPT-4-turbo: ~$0.01 per request
Actual costs vary based on input/output token counts
Common Pitfalls to Avoid
1. Prompt Design Issues
❌ Vague or ambiguous instructions
✅ Clear, specific, testable prompts
2. Error Handling
❌ Ignoring API errors or rate limits
✅ Implement retry logic and graceful degradation
3. Token Management
❌ Exceeding model token limits
✅ Truncate inputs, chunk processing
4. Security
❌ Exposing API keys in code
✅ Use environment variables
5. Testing
❌ Only testing happy paths
✅ Test edge cases, failures, malformed inputs
6. Cost Management
❌ Unmonitored API usage
✅ Implement budgets, alerts, and monitoring
Further Improvements
Production Enhancements
- Monitoring: Add logging, metrics, tracing
- Validation: Input/output schema validation
- Rate Limiting: Implement request throttling
- Caching: Redis or in-memory cache for responses
- Async Support: Non-blocking operations for scalability
Feature Extensions
- Multi-Model Support: Switch between providers
- Fallback Models: Graceful degradation strategy
- Custom Tools: Domain-specific function calling
- Advanced Memory: Vector stores for long-term memory
- Evaluation: Automated testing and benchmarking
Code Quality
- Testing: Unit tests, integration tests
- Documentation: API docs, usage examples
- Type Safety: Stricter type hints
- Configuration: Externalized config files
Related Patterns
- Pattern 009
- Pattern 011
- Other Reasoning Patterns (001-011)
Pattern Families: – Reasoning Patterns (001-011) – Multi-Agent Patterns (012-019) – Tool Use Patterns (020-025) – Memory Patterns (026-031) – And many more…
Summary
The Constitutional Ai pattern provides a powerful approach to building AI agents with specific capabilities. This implementation demonstrates:
✅ Key Strengths: – Clean, maintainable code structure – LangChain integration for composability – Type hints and documentation – Production-ready patterns
🎯 Best Use Cases: – Applications requiring this pattern’s characteristics – Systems needing structured agent behavior – Production environments requiring reliability
📚 Learning Resources: – LangChain Documentation: https://python.langchain.com/ – Pattern Documentation: See related patterns – OpenAI API Reference: https://platform.openai.com/docs/
File: 010_constitutional_ai.py
Total Lines: 528
Pattern Category: AI Agent Design Pattern #010
Generated from actual implementation code
For educational and reference purposes
Leave a Reply