Content Generation Core

Core content generation engine providing LLM-powered content creation with RAG context retrieval, template management, quality scoring, and compliance checking for enterprise content needs.

Core Classes

ContentGenerator

Description: Main content generation engine orchestrating all generation components

Parameters:

• llm (ChatOpenAI): Language model for content generation
• rag_retriever (BaseRetriever, optional): RAG retriever for context
• template_manager (TemplateManager, optional): Template management system
• quality_scorer (QualityScorer, optional): Quality scoring component
• compliance_checker (ContentComplianceChecker, optional): Compliance checking

Returns: ContentGenerator instance

Example:

from recoagent.content_generation import ContentGenerator, ContentGenerationRequest, ContentType
from langchain_openai import ChatOpenAI

# Create content generator
generator = ContentGenerator(
    llm=ChatOpenAI(model="gpt-4", temperature=0.7),
    rag_retriever=rag_retriever,
    template_manager=template_manager,
    quality_scorer=quality_scorer,
    compliance_checker=compliance_checker
)

# Generate content
request = ContentGenerationRequest(
    content_type=ContentType.BLOG_POST,
    topic="Artificial Intelligence in Healthcare",
    target_audience="healthcare professionals",
    word_count=1000,
    tone="professional"
)

result = await generator.generate_content(request)

BlogGenerator

Description: Specialized generator for blog posts and articles

Parameters:

• content_generator (ContentGenerator): Base content generator
• seo_optimizer (SEOOptimizer, optional): SEO optimization component
• readability_analyzer (ReadabilityAnalyzer, optional): Readability analysis

Returns: BlogGenerator instance

Example:

from recoagent.content_generation import BlogGenerator, BlogPostRequest

# Create blog generator
blog_generator = BlogGenerator(
    content_generator=generator,
    seo_optimizer=seo_optimizer,
    readability_analyzer=readability_analyzer
)

# Generate blog post
blog_request = BlogPostRequest(
    title="The Future of AI in Healthcare",
    topic="artificial intelligence healthcare applications",
    target_audience="healthcare professionals",
    word_count=1500,
    include_seo=True,
    readability_level="intermediate"
)

blog_post = await blog_generator.generate_blog_post(blog_request)

EmailGenerator

Description: Specialized generator for email content

Parameters:

• content_generator (ContentGenerator): Base content generator
• personalization_engine (PersonalizationEngine, optional): Personalization component
• a_b_testing (ABTestingEngine, optional): A/B testing component

Returns: EmailGenerator instance

Example:

from recoagent.content_generation import EmailGenerator, EmailRequest

# Create email generator
email_generator = EmailGenerator(
    content_generator=generator,
    personalization_engine=personalization_engine,
    a_b_testing=ab_testing_engine
)

# Generate email
email_request = EmailRequest(
    email_type="newsletter",
    subject="Weekly AI Insights",
    target_audience="tech professionals",
    personalization_data={"name": "John", "company": "TechCorp"},
    include_cta=True
)

email_content = await email_generator.generate_email(email_request)

MarketingGenerator

Description: Specialized generator for marketing content

Parameters:

• content_generator (ContentGenerator): Base content generator
• brand_voice_manager (BrandVoiceManager): Brand voice management
• campaign_optimizer (CampaignOptimizer, optional): Campaign optimization

Returns: MarketingGenerator instance

Example:

from recoagent.content_generation import MarketingGenerator, MarketingRequest

# Create marketing generator
marketing_generator = MarketingGenerator(
    content_generator=generator,
    brand_voice_manager=brand_voice_manager,
    campaign_optimizer=campaign_optimizer
)

# Generate marketing content
marketing_request = MarketingRequest(
    content_type="social_media_post",
    platform="linkedin",
    campaign_goal="lead_generation",
    target_audience="B2B decision makers",
    brand_voice="professional_innovative"
)

marketing_content = await marketing_generator.generate_marketing_content(marketing_request)

Usage Examples

Basic Content Generation

from recoagent.content_generation import ContentGenerator, ContentGenerationRequest, ContentType

# Create content generator
generator = ContentGenerator(
    llm=ChatOpenAI(model="gpt-4", temperature=0.7)
)

# Generate different types of content
content_requests = [
    ContentGenerationRequest(
        content_type=ContentType.BLOG_POST,
        topic="Machine Learning Best Practices",
        target_audience="data scientists",
        word_count=800,
        tone="educational"
    ),
    ContentGenerationRequest(
        content_type=ContentType.EMAIL,
        topic="Product Update Announcement",
        target_audience="existing customers",
        word_count=300,
        tone="friendly"
    ),
    ContentGenerationRequest(
        content_type=ContentType.SOCIAL_MEDIA,
        topic="AI Innovation",
        target_audience="tech enthusiasts",
        word_count=100,
        tone="engaging"
    )
]

# Generate all content
results = []
for request in content_requests:
    result = await generator.generate_content(request)
    results.append(result)
    
    print(f"Generated {request.content_type.value}:")
    print(f"Title: {result.title}")
    print(f"Content: {result.content[:200]}...")
    print(f"Quality Score: {result.quality_scores.overall_score:.2f}")
    print("---")

Advanced Blog Generation with SEO

from recoagent.content_generation import BlogGenerator, BlogPostRequest

# Create blog generator with SEO optimization
blog_generator = BlogGenerator(
    content_generator=generator,
    seo_optimizer=seo_optimizer,
    readability_analyzer=readability_analyzer
)

# Generate SEO-optimized blog post
blog_request = BlogPostRequest(
    title="Complete Guide to AI Implementation",
    topic="artificial intelligence implementation guide",
    target_audience="business leaders",
    word_count=2000,
    include_seo=True,
    readability_level="intermediate",
    target_keywords=["AI implementation", "artificial intelligence", "business AI"],
    meta_description="Learn how to successfully implement AI in your business with this comprehensive guide",
    include_toc=True,
    include_cta=True
)

# Generate blog post
blog_post = await blog_generator.generate_blog_post(blog_request)

print("=== Generated Blog Post ===")
print(f"Title: {blog_post.title}")
print(f"SEO Score: {blog_post.seo_score:.2f}")
print(f"Readability Score: {blog_post.readability_score:.2f}")
print(f"Word Count: {blog_post.word_count}")
print(f"Reading Time: {blog_post.reading_time} minutes")
print(f"Meta Description: {blog_post.meta_description}")
print(f"Table of Contents: {blog_post.table_of_contents}")
print(f"Content: {blog_post.content[:500]}...")

Personalized Email Campaigns

from recoagent.content_generation import EmailGenerator, EmailRequest

# Create email generator with personalization
email_generator = EmailGenerator(
    content_generator=generator,
    personalization_engine=personalization_engine,
    a_b_testing=ab_testing_engine
)

# Generate personalized emails for different segments
email_segments = [
    {
        "segment": "new_customers",
        "audience": "recently signed up users",
        "personalization": {"name": "Sarah", "signup_date": "2024-01-15"},
        "goal": "onboarding"
    },
    {
        "segment": "existing_customers",
        "audience": "long-term customers",
        "personalization": {"name": "Mike", "loyalty_tier": "premium"},
        "goal": "retention"
    },
    {
        "segment": "churned_customers",
        "audience": "inactive users",
        "personalization": {"name": "Lisa", "last_activity": "2023-12-01"},
        "goal": "win_back"
    }
]

# Generate personalized emails
for segment in email_segments:
    email_request = EmailRequest(
        email_type="campaign",
        subject=f"Special Update for {segment['personalization']['name']}",
        target_audience=segment["audience"],
        personalization_data=segment["personalization"],
        campaign_goal=segment["goal"],
        include_personalization=True,
        include_cta=True
    )
    
    email_content = await email_generator.generate_email(email_request)
    
    print(f"=== {segment['segment'].upper()} Email ===")
    print(f"Subject: {email_content.subject}")
    print(f"Personalization: {email_content.personalization_applied}")
    print(f"Content: {email_content.content[:300]}...")
    print("---")

Marketing Content with Brand Voice

from recoagent.content_generation import MarketingGenerator, MarketingRequest

# Create marketing generator with brand voice
marketing_generator = MarketingGenerator(
    content_generator=generator,
    brand_voice_manager=brand_voice_manager,
    campaign_optimizer=campaign_optimizer
)

# Generate marketing content for different platforms
marketing_campaigns = [
    {
        "platform": "linkedin",
        "content_type": "professional_post",
        "audience": "B2B professionals",
        "goal": "thought_leadership",
        "brand_voice": "authoritative_expert"
    },
    {
        "platform": "twitter",
        "content_type": "tweet_thread",
        "audience": "tech enthusiasts",
        "goal": "engagement",
        "brand_voice": "conversational_insightful"
    },
    {
        "platform": "instagram",
        "content_type": "story_caption",
        "audience": "young professionals",
        "goal": "brand_awareness",
        "brand_voice": "inspiring_modern"
    }
]

# Generate platform-specific content
for campaign in marketing_campaigns:
    marketing_request = MarketingRequest(
        content_type=campaign["content_type"],
        platform=campaign["platform"],
        campaign_goal=campaign["goal"],
        target_audience=campaign["audience"],
        brand_voice=campaign["brand_voice"],
        include_hashtags=True,
        include_cta=True
    )
    
    marketing_content = await marketing_generator.generate_marketing_content(marketing_request)
    
    print(f"=== {campaign['platform'].upper()} Content ===")
    print(f"Platform: {marketing_content.platform}")
    print(f"Brand Voice: {marketing_content.brand_voice_applied}")
    print(f"Content: {marketing_content.content}")
    print(f"Hashtags: {marketing_content.hashtags}")
    print("---")

Content Generation with RAG Context

from recoagent.content_generation import ContentGenerator, ContentGenerationRequest
from recoagent.rag.retrievers import HybridRetriever

# Create generator with RAG context
rag_retriever = HybridRetriever(
    vector_retriever=vector_retriever,
    bm25_retriever=bm25_retriever
)

generator_with_rag = ContentGenerator(
    llm=ChatOpenAI(model="gpt-4"),
    rag_retriever=rag_retriever,
    enable_context_retrieval=True
)

# Generate content with RAG context
rag_request = ContentGenerationRequest(
    content_type=ContentType.BLOG_POST,
    topic="Latest AI Research Findings",
    target_audience="AI researchers",
    word_count=1200,
    tone="academic",
    include_citations=True,
    context_requirements={
        "min_sources": 5,
        "max_sources": 10,
        "source_types": ["research_papers", "industry_reports"]
    }
)

# Generate with RAG context
rag_result = await generator_with_rag.generate_content(rag_request)

print("=== RAG-Enhanced Content ===")
print(f"Title: {rag_result.title}")
print(f"Sources Used: {len(rag_result.sources)}")
print(f"Citations: {len(rag_result.citations)}")
print(f"Content: {rag_result.content[:400]}...")
print("\nSources:")
for source in rag_result.sources:
    print(f"  - {source['title']} ({source['type']})")

Quality and Compliance Checking

from recoagent.content_generation import ContentGenerator, QualityScorer, ContentComplianceChecker

# Create generator with quality and compliance checking
quality_scorer = QualityScorer(
    enable_readability_check=True,
    enable_grammar_check=True,
    enable_plagiarism_check=True
)

compliance_checker = ContentComplianceChecker(
    enable_brand_compliance=True,
    enable_legal_compliance=True,
    enable_accessibility_check=True
)

generator_with_quality = ContentGenerator(
    llm=ChatOpenAI(model="gpt-4"),
    quality_scorer=quality_scorer,
    compliance_checker=compliance_checker
)

# Generate content with quality checks
quality_request = ContentGenerationRequest(
    content_type=ContentType.BLOG_POST,
    topic="Healthcare AI Regulations",
    target_audience="healthcare professionals",
    word_count=1000,
    tone="professional",
    quality_requirements={
        "min_readability_score": 0.8,
        "max_grammar_errors": 0,
        "plagiarism_threshold": 0.1
    },
    compliance_requirements={
        "brand_guidelines": True,
        "legal_review": True,
        "accessibility": True
    }
)

# Generate with quality and compliance checks
quality_result = await generator_with_quality.generate_content(quality_request)

print("=== Quality & Compliance Checked Content ===")
print(f"Title: {quality_result.title}")
print(f"Overall Quality Score: {quality_result.quality_scores.overall_score:.2f}")
print(f"Readability Score: {quality_result.quality_scores.readability_score:.2f}")
print(f"Grammar Score: {quality_result.quality_scores.grammar_score:.2f}")
print(f"Plagiarism Score: {quality_result.quality_scores.plagiarism_score:.2f}")
print(f"Compliance Status: {quality_result.compliance_check.status}")
print(f"Compliance Issues: {quality_result.compliance_check.issues}")
print(f"Content: {quality_result.content[:300]}...")

API Reference

ContentGenerator Methods

generate_content(request: ContentGenerationRequest) -> GeneratedContent

Generate content based on request

Parameters:

• request (ContentGenerationRequest): Content generation request

Returns: GeneratedContent with content and metadata

generate_batch(requests: List[ContentGenerationRequest]) -> List[GeneratedContent]

Generate multiple content pieces in batch

Parameters:

• requests (List[ContentGenerationRequest]): List of requests

Returns: List of GeneratedContent objects

BlogGenerator Methods

generate_blog_post(request: BlogPostRequest) -> BlogPost

Generate blog post with SEO optimization

Parameters:

• request (BlogPostRequest): Blog post request

Returns: BlogPost with SEO and readability scores

generate_blog_series(topic: str, num_posts: int) -> List[BlogPost]

Generate series of related blog posts

Parameters:

• topic (str): Series topic
• num_posts (int): Number of posts

Returns: List of BlogPost objects

EmailGenerator Methods

generate_email(request: EmailRequest) -> EmailContent

Generate email content with personalization

Parameters:

• request (EmailRequest): Email request

Returns: EmailContent with personalization applied

generate_email_sequence(sequence_type: str, num_emails: int) -> List[EmailContent]

Generate email sequence

Parameters:

• sequence_type (str): Type of sequence
• num_emails (int): Number of emails

Returns: List of EmailContent objects

MarketingGenerator Methods

generate_marketing_content(request: MarketingRequest) -> MarketingContent

Generate marketing content with brand voice

Parameters:

• request (MarketingRequest): Marketing request

Returns: MarketingContent with brand voice applied

generate_campaign_content(campaign_id: str) -> List[MarketingContent]

Generate content for entire campaign

Parameters:

• campaign_id (str): Campaign identifier

Returns: List of MarketingContent objects

See Also

• RAG Retrievers - Context retrieval for content generation
• LLM Providers - Language models for content generation
• Analytics Core - Content performance analytics
• Security Core - Content compliance and security