AI Commentary Generation

from openai import OpenAI

# OpenAI client with timeout
openai_client = OpenAI(api_key=GPT_KEY, timeout=30.0)

GPT_KEY = os.getenv("GPT_KEY")

if not GPT_KEY:
    raise ValueError("GPT_KEY environment variable is required")

def generate_contextual_commentary(query: str, verse: dict) -> str:
    """
    Generate commentary that specifically addresses the user's question.

    Args:
        query: The user's original question
        verse: Dict with chapter, verse, translation, and optionally full_commentary/summarized_commentary

    Returns:
        Contextual commentary string tailored to the user's question
    """

def generate_contextual_commentary(query: str, verse: dict) -> str:
    """
    Generate commentary that specifically addresses the user's question.

    Args:
        query: The user's original question
        verse: Dict with chapter, verse, translation, and optionally full_commentary/summarized_commentary

    Returns:
        Contextual commentary string tailored to the user's question
    """
    # Get available commentary for context
    commentary_context = verse.get("full_commentary") or verse.get("summarized_commentary") or ""
    if commentary_context:
        commentary_context = f"\n\nTraditional commentary for context:\n{commentary_context[:1500]}"

    prompt = f"""The user asked: "{query}"

The most relevant verse from the Bhagavad Gita is Chapter {verse['chapter']}, Verse {verse['verse']}:
"{verse['translation']}"{commentary_context}

Write a 2-3 paragraph response that:
1. Explains how this verse directly addresses their situation or question
2. Draws practical wisdom they can apply to their life
3. Maintains a warm, thoughtful tone without being preachy

Vary your opening - don't start with "This verse...". Keep it concise but meaningful."""

    response = openai_client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=500,
        temperature=0.7,
    )
    return response.choices[0].message.content.strip()

prompt = f"""The user asked: "{query}"

The most relevant verse from the Bhagavad Gita is Chapter {verse['chapter']}, Verse {verse['verse']}:
"{verse['translation']}"{commentary_context}

Write a 2-3 paragraph response that:
1. Explains how this verse directly addresses their situation or question
2. Draws practical wisdom they can apply to their life
3. Maintains a warm, thoughtful tone without being preachy

Vary your opening - don't start with "This verse...". Keep it concise but meaningful.

response = openai_client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": prompt}],
    max_tokens=500,
    temperature=0.7,
)

@app.post("/api/query", response_model=dict)
@limiter.limit("30/minute")
async def query_gita(request: Request, query: Query) -> dict:
    """
    Query the Gita with the provided query string(s).
    Returns verse with contextual commentary tailored to the user's question.
    """
    try:
        from model import match
        from utils import generate_contextual_commentary

        result = match(query.query)
        if not result:
            raise HTTPException(status_code=404, detail="No matches found")

        # Generate contextual commentary that addresses the user's specific question
        try:
            contextual = generate_contextual_commentary(query.query, result)
            result["summarized_commentary"] = contextual
        except Exception as e:
            # Fall back to pre-computed summary if OpenAI fails
            logging.warning(f"Contextual commentary failed, using fallback: {e}")

        return {"status": "success", "data": result}
    except HTTPException:
        raise
    except Exception as e:
        logging.error(f"Query error: {type(e).__name__}: {e}")
        raise HTTPException(status_code=500, detail="Internal Server Error")

# Generate contextual commentary that addresses the user's specific question
try:
    contextual = generate_contextual_commentary(query.query, result)
    result["summarized_commentary"] = contextual
except Exception as e:
    # Fall back to pre-computed summary if OpenAI fails
    logging.warning(f"Contextual commentary failed, using fallback: {e}")

def summarize(commentary_text: str) -> str:
    """Generate a summary of the commentary using GPT-4o-mini."""
    if not commentary_text or len(commentary_text) < 10:
        return ""

    response = openai_client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {
                "role": "system",
                "content": "You are a helpful assistant that summarizes text concisely but completely.",
            },
            {
                "role": "user",
                "content": f"Summarize the following commentary: {commentary_text}",
            },
        ],
        max_tokens=500,
    )
    return response.choices[0].message.content.strip()

{
    "role": "system",
    "content": "You are a helpful assistant that summarizes text concisely but completely.",
}

<DualCommentary
  contextual={resultData.summarized_commentary}
  traditional={resultData.full_commentary}
/>

export interface VerseData {
  chapter: number;
  verse: number;
  translation: string;
  summarized_commentary: string;  // Contextual or pre-computed
  full_commentary?: string;        // Traditional (optional)
  related?: RelatedVerse[];
}

commentary_context = verse.get("full_commentary") or verse.get("summarized_commentary") or ""
if commentary_context:
    commentary_context = f"\n\nTraditional commentary for context:\n{commentary_context[:1500]}"

Vary your opening - don't start with "This verse...". Keep it concise but meaningful.

# Hash query + verse ID
cache_key = f"{hash(query)}:{verse['chapter']}:{verse['verse']}"

# Check Redis cache
if cached := redis.get(cache_key):
    return cached

# Generate and cache (TTL: 7 days)
commentary = generate_contextual_commentary(query, verse)
redis.setex(cache_key, 604800, commentary)
return commentary

# Detect user language
user_lang = detect_language(query)

# Generate in English first (best quality)
english_commentary = generate_contextual_commentary(query, verse)

# Translate if needed
if user_lang != "en":
    commentary = translate(english_commentary, target=user_lang)
else:
    commentary = english_commentary

# Check logs for specific error
logging.warning(f"Contextual commentary failed, using fallback: {e}")

# Verify API key
openai_client.api_key

# Check rate limits in OpenAI dashboard

from clients import openai_client
response = openai_client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Test"}],
    max_tokens=10
)
print(response.choices[0].message.content)