Claude API से SEO ऑटोमेशन टूल बनाएं — कंटेंट ब्रीफ, मेटा टैग और FAQ+JSON-LD स्वचालित जनरेशन

pip install anthropic python-dotenv

# .env फ़ाइल में
ANTHROPIC_API_KEY=sk-ant-...

import anthropic
from dotenv import load_dotenv
import os

load_dotenv()
client = anthropic.Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

def generate_content_brief(keyword: str, target_audience: str) -> dict:
    """
    दिए गए कीवर्ड के लिए विस्तृत SEO कंटेंट ब्रीफ जनरेट करें
    """
    message = client.messages.create(
        model="claude-opus-4-7",
        max_tokens=2000,
        messages=[
            {
                "role": "user",
                "content": f"""SEO कंटेंट ब्रीफ बनाएं:
                
                मुख्य कीवर्ड: {keyword}
                लक्षित दर्शक: {target_audience}
                
                JSON फ़ॉर्मेट में निम्न शामिल करें:
                - title: H1 टैग (60 अक्षर से कम, कीवर्ड शामिल)
                - meta_description: मेटा विवरण (155 अक्षर)
                - h2_headings: 4-6 H2 शीर्षक
                - target_keywords: 8-12 संबंधित कीवर्ड
                - word_count: अनुशंसित शब्द संख्या
                - content_type: लेख प्रकार (गाइड/तुलना/FAQ आदि)
                """
            }
        ]
    )
    return message.content[0].text

# उपयोग
brief = generate_content_brief(
    keyword="Python वेब स्क्रेपिंग",
    target_audience="मध्यवर्ती Python डेवलपर"
)

def optimize_meta_tags(title: str, content_summary: str) -> dict:
    """
    मौजूदा पेज के लिए SEO-अनुकूलित मेटा टैग जनरेट करें
    """
    message = client.messages.create(
        model="claude-opus-4-7",
        max_tokens=500,
        messages=[
            {
                "role": "user",
                "content": f"""पेज टाइटल: {title}
                कंटेंट सारांश: {content_summary}
                
                JSON में दें:
                - optimized_title: SEO टाइटल (55-60 अक्षर, कीवर्ड पहले)
                - meta_description: मेटा विवरण (150-160 अक्षर, CTA सहित)
                - og_title: Open Graph टाइटल
                - og_description: Open Graph विवरण (200 अक्षर)
                - primary_keyword: मुख्य कीवर्ड
                - secondary_keywords: द्वितीयक कीवर्ड की सूची
                """
            }
        ]
    )
    return message.content[0].text

def generate_faq_with_jsonld(topic: str, num_questions: int = 6) -> dict:
    """
    FAQPage Schema के साथ FAQ जनरेट करें
    """
    message = client.messages.create(
        model="claude-opus-4-7",
        max_tokens=2000,
        messages=[
            {
                "role": "user",
                "content": f"""विषय: {topic}
                
                {num_questions} FAQ प्रश्न और उत्तर बनाएं।
                साथ ही FAQPage Schema.org JSON-LD भी जनरेट करें।
                
                JSON में:
                - faqs: [{{'question': '...', 'answer': '...'}}]
                - jsonld: FAQPage JSON-LD स्ट्रिंग
                
                FAQ की आवश्यकताएं:
                - People Also Ask (PAA) पैटर्न का उपयोग करें
                - उत्तर 50-100 शब्द में सटीक हों
                - मुख्य कीवर्ड उत्तर में शामिल हों
                """
            }
        ]
    )
    return message.content[0].text

def generate_schema(page_type: str, page_data: dict) -> str:
    """
    पेज प्रकार के अनुसार Schema.org JSON-LD जनरेट करें
    page_type: 'article', 'product', 'how-to', 'faq', 'calculator'
    """
    message = client.messages.create(
        model="claude-opus-4-7",
        max_tokens=1500,
        messages=[
            {
                "role": "user",
                "content": f"""पेज डेटा: {page_data}
                पेज प्रकार: {page_type}
                
                Schema.org JSON-LD जनरेट करें:
                - @context: https://schema.org
                - @type: {page_type}के अनुसार सही प्रकार
                - सभी आवश्यक प्रॉपर्टी
                - BreadcrumbList भी शामिल करें
                - WebSite with SearchAction शामिल करें
                """
            }
        ]
    )
    return message.content[0].text

def full_seo_pipeline(keyword: str, url: str, content: str) -> dict:
    """
    एकल फ़ंक्शन से पूर्ण SEO पैकेज जनरेट करें
    """
    results = {}
    
    # 1. कंटेंट ब्रीफ
    results['brief'] = generate_content_brief(keyword, "सामान्य उपयोगकर्ता")
    
    # 2. मेटा टैग
    results['meta'] = optimize_meta_tags(keyword, content[:500])
    
    # 3. FAQ + JSON-LD
    results['faq'] = generate_faq_with_jsonld(keyword)
    
    # 4. Schema
    results['schema'] = generate_schema(
        'article',
        {'title': keyword, 'url': url, 'author': 'MillionsCode'}
    )
    
    return results

# उपयोग
seo_package = full_seo_pipeline(
    keyword="Python डेटा विश्लेषण",
    url="https://example.com/python-data-analysis",
    content="Python डेटा विश्लेषण के लिए..."
)