app.py

import gradio as gr
import os
from datetime import datetime
import json

# Import local modules
try:
    from voice_agent import AstrologyVoiceAgent
    VOICE_AVAILABLE = True
except ImportError:
    VOICE_AVAILABLE = False
    print("Voice agent not available - install elevenlabs package")

# Initialize with sponsor APIs (will be configured with environment variables)
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "")
ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY", "")
ELEVENLABS_API_KEY = os.getenv("ELEVENLABS_API_KEY", "")
GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY", "")

# Initialize voice agent if available
voice_agent = AstrologyVoiceAgent(agent_type="teaching") if VOICE_AVAILABLE and ELEVENLABS_API_KEY else None

# Essential Dignities Tables
DOMICILE_RULERS = {
    "Aries": "Mars", "Taurus": "Venus", "Gemini": "Mercury",
    "Cancer": "Moon", "Leo": "Sun", "Virgo": "Mercury",
    "Libra": "Venus", "Scorpio": "Mars", "Sagittarius": "Jupiter",
    "Capricorn": "Saturn", "Aquarius": "Saturn", "Pisces": "Jupiter"
}

EXALTATIONS = {
    "Aries": "Sun", "Taurus": "Moon", "Gemini": None,
    "Cancer": "Jupiter", "Leo": None, "Virgo": "Mercury",
    "Libra": "Saturn", "Scorpio": None, "Sagittarius": None,
    "Capricorn": "Mars", "Aquarius": None, "Pisces": "Venus"
}

# Detriments (opposite sign of domicile rulership)
DETRIMENTS = {
    "Sun": ["Aquarius"],
    "Moon": ["Capricorn"],
    "Mercury": ["Sagittarius", "Pisces"],
    "Venus": ["Aries", "Scorpio"],
    "Mars": ["Taurus", "Libra"],
    "Jupiter": ["Gemini", "Virgo"],
    "Saturn": ["Cancer", "Leo"]
}

# Falls (opposite sign of exaltation)
FALLS = {
    "Sun": ["Libra"],
    "Moon": ["Scorpio"],
    "Mercury": ["Pisces"],
    "Venus": ["Virgo"],
    "Mars": ["Cancer"],
    "Jupiter": ["Capricorn"],
    "Saturn": ["Aries"]
}

TRIPLICITIES = {
    "Fire": {"day": "Sun", "night": "Jupiter", "participating": "Saturn"},
    "Earth": {"day": "Venus", "night": "Moon", "participating": "Mars"},
    "Air": {"day": "Saturn", "night": "Mercury", "participating": "Jupiter"},
    "Water": {"day": "Venus", "night": "Mars", "participating": "Moon"}
}

SIGN_TRIPLICITIES = {
    "Aries": "Fire", "Leo": "Fire", "Sagittarius": "Fire",
    "Taurus": "Earth", "Virgo": "Earth", "Capricorn": "Earth",
    "Gemini": "Air", "Libra": "Air", "Aquarius": "Air",
    "Cancer": "Water", "Scorpio": "Water", "Pisces": "Water"
}

# Egyptian Bounds (Terms)
EGYPTIAN_BOUNDS = {
    "Aries": [(0, 6, "Jupiter"), (6, 12, "Venus"), (12, 20, "Mercury"), (20, 25, "Mars"), (25, 30, "Saturn")],
    "Taurus": [(0, 8, "Venus"), (8, 14, "Mercury"), (14, 22, "Jupiter"), (22, 27, "Saturn"), (27, 30, "Mars")],
    "Gemini": [(0, 6, "Mercury"), (6, 12, "Jupiter"), (12, 17, "Venus"), (17, 24, "Mars"), (24, 30, "Saturn")],
    "Cancer": [(0, 7, "Mars"), (7, 13, "Venus"), (13, 19, "Mercury"), (19, 26, "Jupiter"), (26, 30, "Saturn")],
    "Leo": [(0, 6, "Jupiter"), (6, 11, "Venus"), (11, 18, "Saturn"), (18, 24, "Mercury"), (24, 30, "Mars")],
    "Virgo": [(0, 7, "Mercury"), (7, 17, "Venus"), (17, 21, "Jupiter"), (21, 28, "Mars"), (28, 30, "Saturn")],
    "Libra": [(0, 6, "Saturn"), (6, 14, "Mercury"), (14, 21, "Jupiter"), (21, 28, "Venus"), (28, 30, "Mars")],
    "Scorpio": [(0, 7, "Mars"), (7, 11, "Venus"), (11, 19, "Mercury"), (19, 24, "Jupiter"), (24, 30, "Saturn")],
    "Sagittarius": [(0, 12, "Jupiter"), (12, 17, "Venus"), (17, 21, "Mercury"), (21, 26, "Saturn"), (26, 30, "Mars")],
    "Capricorn": [(0, 7, "Mercury"), (7, 14, "Jupiter"), (14, 22, "Venus"), (22, 26, "Saturn"), (26, 30, "Mars")],
    "Aquarius": [(0, 7, "Mercury"), (7, 13, "Venus"), (13, 20, "Jupiter"), (20, 25, "Mars"), (25, 30, "Saturn")],
    "Pisces": [(0, 12, "Venus"), (12, 16, "Jupiter"), (16, 19, "Mercury"), (19, 28, "Mars"), (28, 30, "Saturn")]
}

# Decans (Faces)
DECANS = {
    "Aries": [(0, 10, "Mars"), (10, 20, "Sun"), (20, 30, "Venus")],
    "Taurus": [(0, 10, "Mercury"), (10, 20, "Moon"), (20, 30, "Saturn")],
    "Gemini": [(0, 10, "Jupiter"), (10, 20, "Mars"), (20, 30, "Sun")],
    "Cancer": [(0, 10, "Venus"), (10, 20, "Mercury"), (20, 30, "Moon")],
    "Leo": [(0, 10, "Saturn"), (10, 20, "Jupiter"), (20, 30, "Mars")],
    "Virgo": [(0, 10, "Sun"), (10, 20, "Venus"), (20, 30, "Mercury")],
    "Libra": [(0, 10, "Moon"), (10, 20, "Saturn"), (20, 30, "Jupiter")],
    "Scorpio": [(0, 10, "Mars"), (10, 20, "Sun"), (20, 30, "Venus")],
    "Sagittarius": [(0, 10, "Mercury"), (10, 20, "Moon"), (20, 30, "Saturn")],
    "Capricorn": [(0, 10, "Jupiter"), (10, 20, "Mars"), (20, 30, "Sun")],
    "Aquarius": [(0, 10, "Venus"), (10, 20, "Mercury"), (20, 30, "Moon")],
    "Pisces": [(0, 10, "Saturn"), (10, 20, "Jupiter"), (20, 30, "Mars")]
}

# Zodiacal Releasing
ZODIACAL_RELEASING_ORDER = [
    "Cancer", "Leo", "Virgo", "Libra", "Scorpio", "Sagittarius",
    "Capricorn", "Aquarius", "Pisces", "Aries", "Taurus", "Gemini"
]

SIGN_YEARS = {
    "Cancer": 25, "Leo": 19, "Virgo": 20, "Libra": 8, "Scorpio": 15,
    "Sagittarius": 12, "Capricorn": 27, "Aquarius": 30, "Pisces": 12,
    "Aries": 15, "Taurus": 8, "Gemini": 20
}

def calculate_profections(birth_year: int, target_year: int) -> str:
    """Calculate annual profections from Ascendant"""
    age = target_year - birth_year
    profected_house = (age % 12) + 1

    house_meanings = {
        1: "Self, body, vitality, life direction",
        2: "Resources, money, possessions, values",
        3: "Siblings, communication, short journeys, learning",
        4: "Home, family, parents, foundations, endings",
        5: "Children, creativity, pleasure, speculation",
        6: "Health, work, service, daily routines, pets",
        7: "Partnership, marriage, open enemies, contracts",
        8: "Death, transformation, shared resources, inheritance",
        9: "Higher learning, travel, philosophy, religion",
        10: "Career, reputation, authority, public life",
        11: "Friends, groups, hopes, wishes, benefactors",
        12: "Hidden matters, spirituality, isolation, undoing"
    }

    return f"""## Annual Profections

**Birth Year:** {birth_year}
**Target Year:** {target_year}
**Age:** {age}

### Profected House: {profected_house}th House

**Significations:** {house_meanings[profected_house]}

### Lord of the Year:
The ruler of your natal {profected_house}th house becomes your "Lord of the Year" for age {age}.

**How to use this:**
1. Identify which sign is on the cusp of your natal {profected_house}th house
2. The ruler of that sign is activated for this entire year
3. Pay attention to:
   - Transits to the Lord of the Year
   - The condition of the Lord in your natal chart
   - Any planets in your natal {profected_house}th house (also activated)

**Technique from:** Vettius Valens (*Anthology*, Book 4) and Paulus Alexandrinus

### How Profections Work:
Each year of life corresponds to one house, counted from the Ascendant:
- Age 0-11 months: 1st house
- Age 1: 2nd house
- Age 12: Returns to 1st house (first profection return)
- Age {age}: {profected_house}th house

Every 12 years, you return to the same house, creating profection return years.
"""

def assess_planetary_dignity(planet: str, sign: str, is_day_chart: bool) -> str:
    """Assess a planet's essential dignity in a given sign"""
    dignity_score = 0
    dignities = []
    debilities = []

    # Check domicile (+5)
    if DOMICILE_RULERS.get(sign) == planet:
        dignity_score += 5
        dignities.append("Domicile (+5)")

    # Check exaltation (+4)
    if EXALTATIONS.get(sign) == planet:
        dignity_score += 4
        dignities.append("Exaltation (+4)")

    # Check triplicity (+3)
    triplicity = SIGN_TRIPLICITIES.get(sign)
    if triplicity:
        triplicity_rulers = TRIPLICITIES[triplicity]
        if is_day_chart and triplicity_rulers["day"] == planet:
            dignity_score += 3
            dignities.append("Triplicity Ruler - Day (+3)")
        elif not is_day_chart and triplicity_rulers["night"] == planet:
            dignity_score += 3
            dignities.append("Triplicity Ruler - Night (+3)")
        elif triplicity_rulers["participating"] == planet:
            dignity_score += 3
            dignities.append("Triplicity Ruler - Participating (+3)")

    # Check detriment (-5)
    if sign in DETRIMENTS.get(planet, []):
        dignity_score -= 5
        debilities.append("Detriment (-5)")

    # Check fall (-4)
    if sign in FALLS.get(planet, []):
        dignity_score -= 4
        debilities.append("Fall (-4)")

    # Determine condition based on score
    if dignity_score <= -4:
        condition = "Debilitated"
    elif dignity_score < 0:
        condition = "Weak"
    elif dignity_score == 0:
        condition = "Peregrine (no essential dignity)"
    elif dignity_score <= 3:
        condition = "Minor Dignity"
    else:
        condition = "Strong"

    chart_type = "Day Chart" if is_day_chart else "Night Chart"

    # Format as readable text
    result = f"""## Essential Dignity Analysis

**Planet:** {planet}
**Sign:** {sign}
**Chart Type:** {chart_type}

### Dignity Assessment:
"""
    if dignities:
        for dignity in dignities:
            result += f"✓ {dignity}\n"
    else:
        result += "○ No major dignities\n"

    if debilities:
        result += "\n### Debilities:\n"
        for debility in debilities:
            result += f"✗ {debility}\n"

    result += f"""
**Total Dignity Score:** {dignity_score} points
**Planetary Condition:** {condition}

### Interpretation:
"""
    if dignity_score <= -5:
        result += f"{planet} is severely debilitated in {sign}, being in detriment. The planet struggles to express its nature and may act contrary to its essential significations."
    elif dignity_score == -4:
        result += f"{planet} is in fall in {sign}, a position of weakness. The planet cannot act with full strength and may produce difficult outcomes."
    elif dignity_score < 0:
        result += f"{planet} is weakened in {sign} with mixed conditions. The debilities outweigh any minor dignities present."
    elif dignity_score == 0:
        result += f"{planet} is peregrine in {sign}, having no essential dignity. The planet is like a stranger in a foreign land, neither particularly strong nor weak, but without support."
    elif dignity_score <= 3:
        result += f"{planet} has minor dignity in {sign}. The planet has some support but is not at full strength."
    elif dignity_score >= 5:
        result += f"{planet} is very well-placed in {sign}, having its domicile or maximum dignity. The planet can act with full strength and autonomy."
    else:
        result += f"{planet} is strong in {sign}, with significant essential dignity. The planet functions well and can express its significations effectively."

    return result

def calculate_lots(asc_degree: float, sun_degree: float, moon_degree: float, is_day_chart: bool) -> str:
    """Calculate traditional Hellenistic lots (Fortuna and Spirit)"""

    if is_day_chart:
        # Lot of Fortune (day): Asc + Moon - Sun
        fortune = (asc_degree + moon_degree - sun_degree) % 360
    else:
        # Lot of Fortune (night): Asc + Sun - Moon
        fortune = (asc_degree + sun_degree - moon_degree) % 360

    if is_day_chart:
        # Lot of Spirit (day): Asc + Sun - Moon
        spirit = (asc_degree + sun_degree - moon_degree) % 360
    else:
        # Lot of Spirit (night): Asc + Moon - Sun
        spirit = (asc_degree + moon_degree - sun_degree) % 360

    # Convert to sign and degree
    def deg_to_sign(deg):
        signs = ["Aries", "Taurus", "Gemini", "Cancer", "Leo", "Virgo",
                 "Libra", "Scorpio", "Sagittarius", "Capricorn", "Aquarius", "Pisces"]
        sign_num = int(deg // 30)
        sign_deg = deg % 30
        return signs[sign_num], round(sign_deg, 2)

    chart_type = "Day Chart" if is_day_chart else "Night Chart"
    fortune_sign, fortune_deg = deg_to_sign(fortune)
    spirit_sign, spirit_deg = deg_to_sign(spirit)

    formula_fortune = "Asc + Moon - Sun" if is_day_chart else "Asc + Sun - Moon"
    formula_spirit = "Asc + Sun - Moon" if is_day_chart else "Asc + Moon - Sun"

    result = f"""## Traditional Hellenistic Lots

**Chart Type:** {chart_type}

### Lot of Fortune (Fortuna)
**Position:** {fortune_deg}° {fortune_sign} ({round(fortune, 2)}° absolute)
**Formula ({chart_type}):** {formula_fortune}
**Signifies:** Material fortune, body, health, general life circumstances

### Lot of Spirit
**Position:** {spirit_deg}° {spirit_sign} ({round(spirit, 2)}° absolute)
**Formula ({chart_type}):** {formula_spirit}
**Signifies:** Spirit, reputation, career, action in the world

### Notes:
- Lot formulas reverse for day vs night charts (sect consideration)
- In {chart_type.lower()}, Fortune = {formula_fortune}
- Fortune is used for Zodiacal Releasing of general life topics
- Spirit is used for Zodiacal Releasing of career and reputation
"""
    return result

def get_bound_ruler(sign: str, degree: float) -> str:
    """Get the Egyptian bound (term) ruler for a planet's position"""
    if sign not in EGYPTIAN_BOUNDS:
        return f"❌ Error: Invalid sign '{sign}'"

    bounds = EGYPTIAN_BOUNDS[sign]
    for start, end, ruler in bounds:
        if start <= degree < end:
            return f"""## Egyptian Bounds (Terms)

**Position:** {degree}° {sign}

### Bound Ruler: {ruler}
**Range:** {start}°-{end}° of {sign}
**Dignity Points:** +2

### All Bounds in {sign}:
"""+ "\n".join([f"- {s}°-{e}°: {r}" for s, e, r in bounds]) + f"""

### Significance:
The Egyptian bounds divide each sign into 5 unequal sections, each ruled by a different planet. A planet in its own bound gains +2 dignity points. Bounds are used in time-lord techniques and provide refined dignity assessment.
"""

    return f"❌ Error: Degree {degree} is out of range (must be 0-30)"

def get_decan_ruler(sign: str, degree: float) -> str:
    """Get the decan (face) ruler for a planet's position"""
    if sign not in DECANS:
        return f"❌ Error: Invalid sign '{sign}'"

    decans = DECANS[sign]
    for start, end, ruler in decans:
        if start <= degree < end:
            decan_num = (start // 10) + 1
            return f"""## Decans (Faces)

**Position:** {degree}° {sign}

### Decan Ruler: {ruler}
**Decan:** {decan_num} of 3 ({start}°-{end}°)
**Dignity Points:** +1

### All Decans in {sign}:
- 1st Decan (0°-10°): {decans[0][2]}
- 2nd Decan (10°-20°): {decans[1][2]}
- 3rd Decan (20°-30°): {decans[2][2]}

### Significance:
Decans (also called "faces") divide each sign into three equal 10° sections. Each decan is ruled by a planet following the Chaldean order. A planet in its own decan gains +1 dignity point.
"""

    return f"❌ Error: Degree {degree} is out of range (must be 0-30)"

def calculate_zodiacal_releasing(starting_sign: str, birth_year: int, target_year: int = None) -> str:
    """Calculate Zodiacal Releasing periods (simplified version)"""
    if starting_sign not in ZODIACAL_RELEASING_ORDER:
        return f"❌ Error: Invalid starting sign '{starting_sign}'"

    if target_year is None:
        target_year = datetime.now().year

    age = target_year - birth_year
    current_index = ZODIACAL_RELEASING_ORDER.index(starting_sign)
    accumulated_years = 0

    result = f"""## Zodiacal Releasing (Loosing of the Bond)

**Starting Sign:** {starting_sign} (from Lot of Fortune or Spirit)
**Birth Year:** {birth_year}
**Current Year:** {target_year}
**Current Age:** {age}

### Major Periods:

"""

    # Calculate first 8 periods for display
    for i in range(8):
        sign = ZODIACAL_RELEASING_ORDER[(current_index + i) % 12]
        period_years = SIGN_YEARS[sign]

        start_age = int(accumulated_years)
        end_age = int(accumulated_years + period_years)

        is_current = start_age <= age < end_age
        marker = " ← **CURRENT PERIOD**" if is_current else ""

        result += f"{i+1}. **{sign}** - Ages {start_age}-{end_age} ({period_years} years){marker}\n"

        accumulated_years += period_years

    result += f"""
### About Zodiacal Releasing:

From Vettius Valens' *Anthology*, this sophisticated timing technique uses a fixed planetary order through the zodiac signs. Each sign grants a specific number of years:

**Sign Years:**
- Cancer: 25 | Leo: 19 | Virgo: 20 | Libra: 8
- Scorpio: 15 | Sagittarius: 12 | Capricorn: 27 | Aquarius: 30
- Pisces: 12 | Aries: 15 | Taurus: 8 | Gemini: 20

This is a simplified view showing major periods. Full ZR includes minor and sub-minor divisions for precise timing.
"""

    return result

def research_hellenistic_topic(query: str) -> str:
    """Research assistant for Hellenistic astrology topics"""

    topics = {
        "sect": """Sect Theory (Hairesis)

According to Vettius Valens (Anthology, Book III), sect distinguishes between day and night charts:

**Day Chart (Diurnal)**: Sun above horizon at birth
- Benefics: Jupiter, Saturn (traditionally)
- Malefics: Mars more difficult than Saturn
- Solar sect planets: Sun, Jupiter, Saturn

**Night Chart (Nocturnal)**: Sun below horizon at birth
- Benefics: Venus, Moon
- Malefics: Saturn more difficult than Mars
- Lunar sect planets: Moon, Venus, Mars

**Practical Application**:
Ptolemy (Tetrabiblos, Book III) emphasizes that planets in their proper sect are strengthened, while planets contrary to sect are weakened. A day chart with Jupiter angular is far more favorable than Saturn in the same position.

**Source Differences**:
- Valens: More emphasis on sect in time-lord systems
- Ptolemy: More theoretical, applies to natal interpretation
- Dorotheus: Less explicit about sect distinctions
""",
        "profections": """Annual Profections (Epembasis)

The technique advances one house per year of life from the Ascendant.

**Method** (from Valens, Anthology Book IV):
1. Count age in complete years
2. Each year = one house from Ascendant
3. The profected house's ruler becomes the "Lord of the Year"

**Example**:
- Age 0-11 months: 1st house
- Age 1: 2nd house
- Age 12: Returns to 1st house (first return)
- Age 25: 2nd house (third time)

**Application**:
The Lord of the Year is activated. Transits to that planet are significant. The house profected to shows the area of life emphasis.

**Paulus Alexandrinus** adds that planets in the profected house are also activated that year.
""",
        "bounds": """Egyptian Bounds (Terms)

Each sign is divided into five unequal sections, each ruled by a planet.

**Ptolemy vs Egyptian System**:
Ptolemy (Tetrabiblos I.21) presents his own system, but most practitioners use the older Egyptian bounds found in Valens.

**Significance** (per Valens):
- Bounds = +2 dignity points
- Show more refined planet influence within a sign
- Used in time-lord distributions

**Example - Aries** (Egyptian):
- 0-6°: Jupiter
- 6-12°: Venus
- 12-20°: Mercury
- 20-25°: Mars
- 25-30°: Saturn
""",
        "zodiacal releasing": """Zodiacal Releasing (Aphesis)

From Vettius Valens (Anthology, Book IV), this is the most sophisticated Hellenistic time-lord technique.

**Basic Method**:
1. Start from Spirit (day) or Fortune (night) lot
2. Each sign has a planetary ruler and period length
3. Periods subdivide into smaller periods
4. Loosing of the bond = major life transitions

**Period Lengths** (years per sign):
- Aries/Scorpio (Mars): 15 years
- Taurus/Libra (Venus): 8 years
- Gemini/Virgo (Mercury): 20 years
- Cancer (Moon): 25 years
- Leo (Sun): 19 years
- Sagittarius/Pisces (Jupiter): 12 years
- Capricorn/Aquarius (Saturn): 30 years

**Peak Periods**:
When the releasing reaches the natal position of the Lot, or angular houses (1st, 10th, 7th, 4th).

**Valens' Example**:
In Anthology IV, Valens demonstrates using ZR to time major career events, marriages, and deaths. The technique requires understanding both general and specific periods.

**Modern Application**:
Chris Brennan's work has revived this technique. Look for "loosing of the bond" (when releasing completes a full cycle) as major turning points.
"""
    }

    # Simple keyword matching
    query_lower = query.lower()
    for keyword, content in topics.items():
        if keyword in query_lower:
            return content

    # If no match, try using Gemini API
    if GOOGLE_API_KEY:
        try:
            import google.generativeai as genai

            genai.configure(api_key=GOOGLE_API_KEY)
            model = genai.GenerativeModel('gemini-2.5-flash')

            # Create a specialized prompt for Hellenistic astrology
            prompt = f"""You are an expert in Hellenistic astrology (1st-7th century CE).
Answer this question with references to classical sources when possible:

Question: {query}

Please include citations from:
- Vettius Valens (Anthology)
- Claudius Ptolemy (Tetrabiblos)
- Dorotheus of Sidon (Carmen Astrologicum)
- Paulus Alexandrinus
- Or other relevant ancient sources

Provide a clear, educational response suitable for students of traditional astrology."""

            response = model.generate_content(prompt)

            return f"""## {query}

{response.text}

---
*Response generated by Google Gemini AI with classical astrology context*
"""
        except ImportError:
            pass  # Fall through to fallback
        except Exception as e:
            return f"""## Error using AI research

{str(e)}

Please check your GOOGLE_API_KEY environment variable.

**Fallback**: Try asking about "sect", "profections", "bounds", or "zodiacal releasing" for built-in content.
"""

    # Fallback if no API key or error
    return f"""## Research Query: "{query}"

**Available built-in topics** (instant responses):
- "sect" or "sect theory"
- "profections" or "annual profections"
- "bounds" or "egyptian bounds"
- "zodiacal releasing"

**For other topics**, please set the GOOGLE_API_KEY environment variable to enable AI-powered research through ancient texts.

**To set up**:
1. Get a free API key from: https://ai.google.dev/
2. Add to HuggingFace Space secrets: `GOOGLE_API_KEY=your_key_here`
3. Restart the Space

**Classical Sources Available via AI**:
- Vettius Valens (Anthology)
- Ptolemy (Tetrabiblos)
- Dorotheus (Carmen Astrologicum)
- Paulus Alexandrinus
- Modern synthesizers: Chris Brennan, Demetra George, Robert Schmidt
"""

# Gradio Interface
def create_demo():
    with gr.Blocks(
        theme=gr.themes.Soft(primary_hue="purple", secondary_hue="blue"),
        title="HERMES - Hellenistic Astrology Research Assistant",
        css="""
        .purple-banner {
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            padding: 2rem;
            border-radius: 10px;
            color: white;
            text-align: center;
            margin-bottom: 2rem;
            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
        }
        .purple-banner h1 {
            margin: 0 0 0.5rem 0;
            font-size: 2.5rem;
            font-weight: 700;
        }
        .purple-banner p {
            margin: 0;
            font-size: 1.2rem;
            opacity: 0.95;
        }
        .banner-badges {
            margin-top: 1rem;
            display: flex;
            gap: 1rem;
            justify-content: center;
            flex-wrap: wrap;
        }
        .banner-badge {
            background: rgba(255, 255, 255, 0.2);
            padding: 0.5rem 1rem;
            border-radius: 20px;
            font-size: 0.9rem;
            backdrop-filter: blur(10px);
        }
        """
    ) as demo:

        gr.HTML("""
        <div class="purple-banner">
            <h1>🏛️ HERMES - Hellenistic Ephemeris Research & MCP Educational System</h1>
            <p>Ancient Wisdom Meets Modern AI Through the Model Context Protocol</p>
            <div class="banner-badges">
                <span class="banner-badge">🔗 4 MCP Servers Integrated</span>
                <span class="banner-badge">🏆 MCP Birthday Hackathon</span>
                <span class="banner-badge">📚 2000+ Years of Wisdom</span>
                <span class="banner-badge">✨ 10,000+ Students</span>
            </div>
        </div>
        """)

        gr.Markdown("""
        ## ✨ What is HERMES?

        An interactive research and teaching tool for traditional Hellenistic astrology, combining 2000-year-old techniques
        from ancient Greek and Roman astrologers with modern AI agents and the Model Context Protocol (MCP).

        ## ✨ What You Can Do Here:

        ### 📊 Chart Calculations
        - **Essential Dignities** - Assess planetary strength through domicile, exaltation, and triplicity
        - **Traditional Lots** - Calculate the Lots of Fortune and Spirit with proper sect consideration
        - **Egyptian Bounds** - Determine bound (term) rulers for refined dignity assessment
        - **Decans (Faces)** - Find decan rulers following the Chaldean order

        ### ⏱️ Time-Lord Techniques
        - **Annual Profections** - Discover your Lord of the Year for any age
        - **Zodiacal Releasing** - Explore major life periods from Vettius Valens' system

        ### 🎓 Learn Traditional Astrology
        - **Text-Based Teaching** - AI-powered explanations of Hellenistic techniques
        - **Source Research** - Educational content citing ancient texts
        - **Study Resources** - Curated books, courses, and free learning materials

        ### 🌐 External Integrations
        - **Modal Serverless** - 6 MCP functions deployed for calculations
        - **Astro.com MCP** - Classical Hellenistic chart generation
        - **Local Fallback** - All calculations available offline

        ### 🏛️ Built on Ancient Foundations
        All techniques are drawn from authentic Hellenistic sources (1st-7th century CE),
        not modern psychological astrology. We preserve the traditional methods exactly as
        taught by Valens, Ptolemy, and Dorotheus.

        ---

        **Built for the MCP 1st Birthday Hackathon** | Powered by OpenAI, Anthropic, ElevenLabs & Modal
        """)
        
        with gr.Tab("🔗 MCP Integrations"):
            gr.Markdown("""
            # 🌐 Model Context Protocol (MCP) Integration Showcase

            HERMES demonstrates the power of MCP by integrating **4 different calculation backends**:

            1. 🏠 **Local MCP** - Core features running locally
            2. ☁️ **Modal Serverless** - Cloud-deployed time-lord calculations
            3. 📊 **Astro.com** - Classical Hellenistic chart generation
            4. 🤖 **Google Gemini AI** - Natural language astrology conversations

            ### Why MCP Matters for HERMES

            The Model Context Protocol allows HERMES to:
            - **Scale**: Offload heavy calculations to cloud (Modal)
            - **Integrate**: Connect to third-party services (Astro.com)
            - **Converse**: Use AI for educational explanations (Gemini)
            - **Fallback**: Gracefully degrade when services unavailable
            - **Extend**: Easy to add new calculation sources
            """)

            gr.Markdown("---")

            # MCP Server 1: Local HERMES
            with gr.Accordion("🏠 Local HERMES MCP Server", open=True):
                gr.Markdown("""
                ### Local MCP Server

                Runs **directly on your machine** with instant responses.

                **Features:**
                - Essential Dignities (5-level system)
                - Annual Profections
                - Lot of Fortune calculations
                - Educational explanations

                **Status**: ✅ Always Available (no internet required)
                """)

                with gr.Row():
                    with gr.Column():
                        gr.Markdown("#### Test Essential Dignity")
                        local_planet = gr.Dropdown(
                            choices=["Sun", "Moon", "Mercury", "Venus", "Mars", "Jupiter", "Saturn"],
                            label="Planet",
                            value="Venus"
                        )
                        local_sign = gr.Dropdown(
                            choices=["Aries", "Taurus", "Gemini", "Cancer", "Leo", "Virgo",
                                    "Libra", "Scorpio", "Sagittarius", "Capricorn", "Aquarius", "Pisces"],
                            label="Sign",
                            value="Aries"
                        )
                        local_degree = gr.Number(label="Degree (0-30)", value=8.5, precision=1)
                        local_is_day = gr.Checkbox(label="Day Chart", value=True)
                        local_dignity_btn = gr.Button("🔍 Calculate via Local MCP", variant="primary")

                    with gr.Column():
                        local_output = gr.Textbox(
                            label="Local MCP Result",
                            lines=15,
                            show_copy_button=True
                        )

                def test_local_mcp(planet, sign, degree, is_day):
                    """Test local MCP server"""
                    try:
                        from hermes_local_mcp import HermesLocalMCP

                        server = HermesLocalMCP()
                        result = server.calculate_essential_dignity(planet, sign, degree, is_day)

                        output = f"""## ✅ Local MCP Response

**Server**: {result.get('source', 'Local MCP')}
**Planet**: {result['planet']} at {result['degree']}° {result['sign']}
**Chart Type**: {result['chart_type']}

### Dignity Assessment:
**Score**: {result['dignity_score']} points
**Condition**: {result['condition']}

### Dignities:
{chr(10).join(f'✓ {d}' for d in result['dignities']) if result['dignities'] else '○ No major dignities'}

### Debilities:
{chr(10).join(f'✗ {d}' for d in result['debilities']) if result['debilities'] else '○ No debilities'}

### Interpretation:
{result['interpretation']}

---
*Via: Local HERMES MCP Server (instant response, no internet required)*
"""
                        return output

                    except Exception as e:
                        return f"❌ Error: {str(e)}"

                local_dignity_btn.click(
                    fn=test_local_mcp,
                    inputs=[local_planet, local_sign, local_degree, local_is_day],
                    outputs=local_output
                )

            gr.Markdown("---")

            # MCP Server 2: Modal Serverless
            with gr.Accordion("☁️ Modal Serverless MCP", open=False):
                gr.Markdown("""
                ### Modal Serverless MCP

                **Cloud-deployed** calculation functions on Modal infrastructure.

                **Features:**
                - Zodiacal Releasing
                - Firdaria
                - Bounds & Decans
                - Essential Dignities (cloud version)
                - Fixed Stars

                **Status**: ✅ Deployed at modal.com
                **Endpoint**: `modal app list` to view deployment

                **Benefits:**
                - Zero local compute overhead
                - Scales automatically
                - Same API as local MCP
                - Graceful fallback to local

                **Test it:** Use the Time Lords tab - calculations run on Modal!
                """)

                gr.Code("""
# Example: Using Modal MCP from Python

from modal import Function

# Call serverless function
result = Function.lookup("hermes-mcp", "calculate_zodiacal_releasing").remote(
    birth_date="1990-01-15",
    birth_time="12:00"
)

print(result)  # Returns ZR periods from cloud
                """, language="python")

            gr.Markdown("---")

            # MCP Server 3: Astro.com Integration
            with gr.Accordion("📊 Astro.com (AstroDienst) MCP", open=False):
                gr.Markdown("""
                ### Astro.com Classical Chart Generator

                Generate **classical Hellenistic charts** using Astro.com infrastructure.

                **Features:**
                - Whole Sign house system
                - Traditional aspects
                - Chart URL generation
                - Hellenistic interpretation guides

                **Status**: 🟡 Proof-of-concept (URL generation)
                """)

                with gr.Row():
                    with gr.Column():
                        gr.Markdown("#### Chart Request")
                        astro_date = gr.Textbox(label="Birth Date (DD.MM.YYYY)", value="15.01.1990")
                        astro_time = gr.Textbox(label="Birth Time (HH:MM)", value="12:00")
                        astro_city = gr.Textbox(label="City", value="New York")
                        astro_country = gr.Textbox(label="Country", value="USA")
                        astro_house_system = gr.Dropdown(
                            choices=[
                                ("Whole Sign (Hellenistic)", "W"),
                                ("Placidus", "P"),
                                ("Koch", "K"),
                                ("Equal House", "E")
                            ],
                            label="House System",
                            value="W"
                        )
                        astro_btn = gr.Button("🔍 Generate Chart via Astro.com MCP", variant="primary")

                    with gr.Column():
                        astro_output = gr.Textbox(
                            label="Astro.com MCP Result",
                            lines=15,
                            show_copy_button=True
                        )

                def test_astrodienst_mcp(date, time, city, country, house_system):
                    """Test Astro.com MCP"""
                    try:
                        from astrodienst_mcp import AstroDienstMCP

                        server = AstroDienstMCP()
                        result = server.generate_chart(date, time, city, country, house_system)

                        output = f"""## 📊 Astro.com MCP Response

**Service**: {result['service']}
**Birth Data**: {result['birth_date']} at {result['birth_time']}
**Location**: {result['location']}
**House System**: {result['house_system']}

### Chart URL:
{result['chart_url']}

### Instructions:
{chr(10).join(f"{i}. {inst}" for i, inst in enumerate(result['instructions'], 1))}

### Hellenistic Features:
- Whole Sign Houses: {'✅ Yes' if result['hellenistic_features']['whole_sign_houses'] else '❌ No'}
- Traditional Aspects: {'✅ Included' if result['hellenistic_features']['traditional_aspects'] else '❌ No'}
- Sect Awareness: {result['hellenistic_features']['sect_aware']}
- Essential Dignities: {result['hellenistic_features']['essential_dignities']}

### Note:
{result['note']}

---
*Via: AstroDienst MCP Integration*
"""
                        return output

                    except Exception as e:
                        return f"❌ Error: {str(e)}"

                astro_btn.click(
                    fn=test_astrodienst_mcp,
                    inputs=[astro_date, astro_time, astro_city, astro_country, astro_house_system],
                    outputs=astro_output
                )

            gr.Markdown("---")

            # MCP Server 4: Google Gemini AI
            with gr.Accordion("🤖 Google Gemini AI MCP", open=True):
                gr.Markdown("""
                ### Natural Language Astrology Conversations

                Ask questions about Hellenistic astrology in **plain English**.
                Powered by Google Gemini AI with specialized knowledge of traditional techniques.

                **Features:**
                - Explain techniques (dignities, profections, etc.)
                - Interpret placements
                - Answer questions with sources
                - Compare different methods
                - Educational, not predictive

                **Status**: 🔑 Requires GOOGLE_API_KEY (free at makersuite.google.com)
                """)

                with gr.Row():
                    with gr.Column():
                        gr.Markdown("#### Ask a Question")
                        gemini_api_key = gr.Textbox(
                            label="Google Gemini API Key (Optional)",
                            placeholder="Enter your API key or leave blank for fallback responses",
                            type="password",
                            info="Get free key at: https://makersuite.google.com/app/apikey"
                        )
                        gemini_question = gr.Textbox(
                            label="Your Question",
                            placeholder="What are essential dignities in Hellenistic astrology?",
                            lines=3
                        )
                        gemini_btn = gr.Button("🤖 Ask Gemini via MCP", variant="primary")
                        gr.Markdown("**Example questions:**")
                        gr.Markdown("""
- What are essential dignities?
- How does sect work in Hellenistic astrology?
- Explain annual profections step by step
- What are Whole Sign houses?
- Compare profections vs zodiacal releasing
                        """)

                    with gr.Column():
                        gemini_output = gr.Textbox(
                            label="Gemini AI Response",
                            lines=20,
                            show_copy_button=True
                        )

                def test_gemini_mcp(api_key, question):
                    """Test Gemini MCP"""
                    try:
                        import os
                        from gemini_mcp import GeminiMCP

                        # Temporarily set API key if provided
                        original_key = os.environ.get('GOOGLE_API_KEY')
                        if api_key and api_key.strip():
                            os.environ['GOOGLE_API_KEY'] = api_key.strip()

                        server = GeminiMCP()
                        result = server.ask_question(question, include_sources=True)

                        # Restore original key
                        if original_key:
                            os.environ['GOOGLE_API_KEY'] = original_key
                        elif api_key and api_key.strip():
                            del os.environ['GOOGLE_API_KEY']

                        if "error" in result:
                            return f"""## ⚠️ API Key Required

{result.get('message', 'Gemini API not configured')}

### Fallback Response:

{result.get('fallback', 'No fallback available')}

---

**To enable full Gemini AI:**
1. Get free API key: https://makersuite.google.com/app/apikey
2. Set environment variable: `GOOGLE_API_KEY=your-key`
3. Restart application

**Or use the fallback responses above for common questions.**
"""

                        output = f"""## 🤖 Gemini AI Response (via MCP)

**Question**: {result['question']}

**Model**: {result.get('model', 'gemini-pro')}
**Conversation Turn**: {result.get('conversation_turn', 1)}

---

{result['answer']}

---
*Via: Google Gemini MCP Server*
*Source: {result['source']}*
"""
                        return output

                    except Exception as e:
                        return f"❌ Error: {str(e)}"

                gemini_btn.click(
                    fn=test_gemini_mcp,
                    inputs=[gemini_api_key, gemini_question],
                    outputs=gemini_output
                )

            gr.Markdown("---")

            # MCP Architecture Diagram
            gr.Markdown("""
            ## 🏗️ HERMES MCP Architecture

            ```
            ┌─────────────────────────────────────────────────────────────┐
            │                    HERMES Application                       │
            │                     (Gradio UI)                             │
            └─────────────────────┬───────────────────────────────────────┘
                                  │
                    ┌─────────────┴─────────────┐
                    │   MCP Protocol Layer      │
                    │   (Unified Interface)     │
                    └─────────────┬─────────────┘
                                  │
            ┌─────────────────────┼─────────────────────┬─────────────────┐
            │                     │                     │                 │
        ┌───▼────┐       ┌────────▼────────┐    ┌─────▼──────┐    ┌────▼─────┐
        │ Local  │       │ Modal Serverless │    │ Astro.com  │    │ Gemini   │
        │  MCP   │       │      MCP         │    │    MCP     │    │   AI MCP │
        └────────┘       └──────────────────┘    └────────────┘    └──────────┘
            │                     │                     │                 │
            │                     │                     │                 │
        Fast &            Scalable Cloud        Classical Chart     AI-Powered
        Reliable          Calculations         Generation          Teaching
            ```

            ### Key Benefits:

            1. **Modularity**: Each MCP server is independent
            2. **Scalability**: Cloud functions handle heavy computation
            3. **Resilience**: Automatic fallback if services unavailable
            4. **Extensibility**: Easy to add new data sources
            5. **Interoperability**: Standard protocol across all backends

            ### MCP Configuration

            All servers configured in `.mcp_config.json`:
            """)

            gr.Code("""{
  "mcpServers": {
    "hermes-local": "Local calculations",
    "hermes-modal": "Modal serverless",
    "astrodienst": "Astro.com charts",
    "gemini": "AI conversations"
  },
  "settings": {
    "default_server": "hermes-local",
    "fallback_chain": ["hermes-modal", "hermes-local"]
  }
}""", language="json")

            gr.Markdown("""
            ### Try It Yourself

            1. **Test each MCP server** using the accordions above
            2. **Compare performance** between local and cloud
            3. **See fallback behavior** when services unavailable
            4. **Check the code** in `hermes_local_mcp.py`, `astrodienst_mcp.py`, `gemini_mcp.py`

            ### For Hackathon Judges

            HERMES demonstrates **MCP's value** by:
            - ✅ Integrating 4 different calculation backends
            - ✅ Showing graceful fallback (Modal → Local)
            - ✅ Connecting to external services (Astro.com)
            - ✅ Using AI for education (Gemini)
            - ✅ Maintaining consistent interface across all backends

            This architecture makes ancient astrology accessible through modern protocols!
            """)

        with gr.Tab("📊 Chart Analysis"):
            gr.Markdown("### Essential Dignity Calculator")
            
            with gr.Row():
                planet_input = gr.Dropdown(
                    choices=["Sun", "Moon", "Mercury", "Venus", "Mars", "Jupiter", "Saturn"],
                    label="Planet",
                    value="Sun"
                )
                sign_input = gr.Dropdown(
                    choices=list(DOMICILE_RULERS.keys()),
                    label="Sign",
                    value="Aries"
                )
                sect_input = gr.Checkbox(label="Day Chart (uncheck for Night Chart)", value=True)
            
            dignity_btn = gr.Button("Assess Planetary Condition", variant="primary")
            dignity_output = gr.Markdown(label="Dignity Analysis")

            dignity_btn.click(
                fn=assess_planetary_dignity,
                inputs=[planet_input, sign_input, sect_input],
                outputs=dignity_output
            )

            gr.Markdown("### Lot Calculator")
            with gr.Row():
                asc_deg = gr.Number(label="Ascendant (degrees 0-360)", value=0)
                sun_deg = gr.Number(label="Sun (degrees 0-360)", value=45)
                moon_deg = gr.Number(label="Moon (degrees 0-360)", value=180)

            lot_sect = gr.Checkbox(label="Day Chart", value=True)
            lot_btn = gr.Button("Calculate Lots", variant="primary")
            lot_output = gr.Markdown(label="Traditional Lots")

            lot_btn.click(
                fn=calculate_lots,
                inputs=[asc_deg, sun_deg, moon_deg, lot_sect],
                outputs=lot_output
            )
        
        with gr.Tab("📚 Source Research"):
            gr.Markdown("""
            ### Hellenistic Astrology Knowledge Base
            Ask about traditional techniques and get answers citing ancient sources.
            """)
            
            research_query = gr.Textbox(
                label="Research Question",
                placeholder="e.g., 'Explain sect theory' or 'What are profections?' or 'Describe Egyptian bounds'",
                lines=2
            )
            
            research_btn = gr.Button("Search Ancient Sources", variant="primary")
            research_output = gr.Textbox(label="Research Results", lines=20)
            
            research_btn.click(
                fn=research_hellenistic_topic,
                inputs=research_query,
                outputs=research_output
            )
            
            gr.Markdown("""
            **Sources Referenced:**
            - Vettius Valens (*Anthology*)
            - Ptolemy (*Tetrabiblos*)
            - Dorotheus of Sidon (*Carmen Astrologicum*)
            - Paulus Alexandrinus
            - Modern: Chris Brennan, Demetra George, Robert Schmidt
            """)
        
        with gr.Tab("⏱️ Time-Lord Systems"):
            gr.Markdown("### Annual Profections Calculator")
            
            with gr.Row():
                birth_year_input = gr.Number(label="Birth Year", value=1990)
                target_year_input = gr.Number(label="Target Year", value=2025)
            
            profection_btn = gr.Button("Calculate Profections", variant="primary")
            profection_output = gr.Markdown(label="Profection Results")

            profection_btn.click(
                fn=calculate_profections,
                inputs=[birth_year_input, target_year_input],
                outputs=profection_output
            )

        with gr.Tab("🎯 Bounds & Decans"):
            gr.Markdown("""
            ### Egyptian Bounds (Terms) & Decans (Faces)
            Calculate the sub-rulerships within each sign for refined essential dignity assessment.
            """)

            with gr.Row():
                bound_sign = gr.Dropdown(
                    choices=list(DOMICILE_RULERS.keys()),
                    label="Sign",
                    value="Aries"
                )
                bound_degree = gr.Number(label="Degree (0-30)", value=15, minimum=0, maximum=30)

            with gr.Row():
                bound_btn = gr.Button("Get Bound Ruler", variant="primary")
                decan_btn = gr.Button("Get Decan Ruler", variant="secondary")

            bound_output = gr.Markdown(label="Results")

            bound_btn.click(
                fn=get_bound_ruler,
                inputs=[bound_sign, bound_degree],
                outputs=bound_output
            )

            decan_btn.click(
                fn=get_decan_ruler,
                inputs=[bound_sign, bound_degree],
                outputs=bound_output
            )

            gr.Markdown("""
            **About Bounds & Decans:**

            - **Egyptian Bounds** (Terms): Each sign divided into 5 unequal sections ruled by planets (+2 dignity points)
            - **Decans** (Faces): Each sign divided into 3 equal 10° sections (+1 dignity point)

            These sub-rulers provide more refined assessment of planetary condition and are used in advanced time-lord techniques.

            Source: Vettius Valens, Ptolemy (though he presents his own bounds system)
            """)

        with gr.Tab("🌟 Zodiacal Releasing"):
            gr.Markdown("""
            ### Zodiacal Releasing (Loosing of the Bond)
            Advanced time-lord system from Vettius Valens using the Lot of Fortune or Spirit.
            """)

            with gr.Row():
                zr_starting_sign = gr.Dropdown(
                    choices=ZODIACAL_RELEASING_ORDER,
                    label="Starting Sign (where Lot of Fortune/Spirit falls)",
                    value="Cancer"
                )

            with gr.Row():
                zr_birth_year = gr.Number(label="Birth Year", value=1990)
                zr_target_year = gr.Number(label="Target Year (optional)", value=2025)

            zr_btn = gr.Button("Calculate Zodiacal Releasing Periods", variant="primary")
            zr_output = gr.Markdown(label="ZR Periods")

            zr_btn.click(
                fn=calculate_zodiacal_releasing,
                inputs=[zr_starting_sign, zr_birth_year, zr_target_year],
                outputs=zr_output
            )

        with gr.Tab("🎓 Learning Center"):
            gr.Markdown("""
            ### Interactive Voice Teaching
            Learn Hellenistic astrology techniques with AI-powered voice explanations.
            """)

            if voice_agent and ELEVENLABS_API_KEY:
                gr.Markdown("""
                ⚠️ **Voice Feature Status**: ElevenLabs audio requires a paid subscription when running on HuggingFace Spaces (free tier blocked due to proxy detection).

                Text explanations are fully available below! For voice audio, consider running HERMES locally.
                """)

                technique_choice = gr.Dropdown(
                    choices=["Annual Profections", "Sect Theory", "Zodiacal Releasing",
                             "Essential Dignities", "Lots (Fortune & Spirit)", "Bounds & Decans"],
                    label="Choose a Technique to Learn",
                    value="Annual Profections"
                )

                teach_btn = gr.Button("📖 Get Text Explanation", variant="primary")

                text_output = gr.Textbox(
                    label="Text Explanation",
                    lines=20,
                    max_lines=30,
                    show_copy_button=True,
                    container=True
                )

                def get_teaching_explanation(technique):
                    """Get text explanation (audio disabled due to ElevenLabs free tier restrictions on HF Spaces)"""
                    technique_map = {
                        "Annual Profections": "annual_profections",
                        "Sect Theory": "sect_theory",
                        "Zodiacal Releasing": "zodiacal_releasing"
                    }
                    key = technique_map.get(technique, technique.lower().replace(" ", "_"))
                    text = voice_agent.explain_technique(key)
                    return text

                teach_btn.click(
                    fn=get_teaching_explanation,
                    inputs=technique_choice,
                    outputs=text_output
                )
            else:
                gr.Markdown("⚠️ Voice teaching requires ELEVENLABS_API_KEY to be set in environment")
                gr.Markdown("Add the API key in HuggingFace Space Settings → Repository Secrets")

            gr.Markdown("""
            ---
            ### 📚 Educational Resources

            **Recommended Books:**
            - **Chris Brennan** - [*Hellenistic Astrology: The Study of Fate and Fortune*](https://www.hellenisticastrology.com/book/)
              - Comprehensive modern treatment of traditional techniques
              - Available at: https://www.hellenisticastrology.com
            - **Demetra George** - *Ancient Astrology in Theory and Practice* (2 volumes)
            - **Vettius Valens** - *The Anthology* (Project Hindsight translation)
            - **Claudius Ptolemy** - *Tetrabiblos* (Schmidt translation)

            **Online Resources:**
            - [The Astrology Podcast](https://theastrologypodcast.com) by Chris Brennan
            - [Hellenistic Astrology Website](https://www.hellenisticastrology.com) - Courses, articles, chart examples
            - [Project Hindsight](http://www.projecthindsight.com) - Ancient text translations

            **Free Learning:**
            - Chris Brennan's YouTube channel - Technique tutorials and demonstrations
            - [Astrology Podcast Episodes on Hellenistic Techniques](https://theastrologypodcast.com/hellenistic-astrology/)

            **Study Path:**
            1. Start with essential dignities and sect
            2. Learn the lot calculations (Fortune, Spirit)
            3. Master annual profections for yearly forecasting
            4. Progress to zodiacal releasing for life periods
            5. Explore bounds, decans, and advanced timing
            """)

        with gr.Tab("ℹ️ About"):
            gr.Markdown("""
            ## About HERMES

            **Hellenistic Ephemeris Research & MCP Educational System**

            ### Purpose
            HERMES is a research and teaching tool for traditional Hellenistic astrology, bridging
            2000-year-old wisdom with modern AI technology.
            
            ### Technical Stack
            - **Agent Framework**: OpenAI GPT-4 + Anthropic Claude
            - **Teaching**: Text-based AI explanations
            - **MCP Server**: Python + Modal (serverless) ✅ **DEPLOYED**
            - **UI**: Gradio 5.49+ on HuggingFace Spaces
            - **Ephemeris**: Swiss Ephemeris (pyswisseph)

            ### MCP Server Features (Modal Serverless)
            The HERMES MCP server is deployed on Modal with 6 serverless functions:
            - `calculate_zodiacal_releasing` - Time-lord periods from Vettius Valens
            - `calculate_firdaria` - Persian time-lord system
            - `get_bound_ruler` - Egyptian bounds (terms)
            - `get_decan_ruler` - Decans (faces)
            - `calculate_full_dignities` - Complete essential dignity analysis
            - `find_fixed_stars` - Fixed star conjunction database

            **Live at**: `modal.com/apps/aamanlamba/hermes-astrology-mcp`

            ### Interactive Features
            - Essential dignity calculations (domicile, exaltation, triplicity, bounds, decans)
            - Time-lord systems (annual profections, zodiacal releasing)
            - Traditional lot calculations (Fortune, Spirit with sect consideration)
            - Source research with citations to ancient texts
            - AI-powered teaching explanations
            
            ### Educational Use Cases
            1. **Students**: Interactive learning of complex traditional techniques
            2. **Researchers**: Rapid comparison across source texts and translations
            3. **Practitioners**: Chart analysis using authentic Hellenistic methods
            
            ### Built For
            MCP 1st Birthday Hackathon (Nov 14-30, 2025)
            
            ### Author
            Created by an astrology author and strategy consultant
            
            ### Credits & Acknowledgments

            **Hackathon Sponsors:**
            - Anthropic, OpenAI, ElevenLabs, Modal, HuggingFace

            **Ancient Sources:**
            - Vettius Valens (*Anthology*, 2nd century CE)
            - Claudius Ptolemy (*Tetrabiblos*, 2nd century CE)
            - Dorotheus of Sidon (*Carmen Astrologicum*, 1st century CE)
            - Firmicus Maternus, Paulus Alexandrinus, Rhetorius

            **Modern Teachers & Resources:**
            - **Chris Brennan** - [*Hellenistic Astrology: The Study of Fate and Fortune*](https://www.hellenisticastrology.com/book/)
              - The definitive modern text on Hellenistic astrology
              - Host of [The Astrology Podcast](https://theastrologypodcast.com)
              - Courses and resources at [HellenisticAstrology.com](https://www.hellenisticastrology.com)
            - **Demetra George** - Traditional astrology teacher and author
            - **Robert Schmidt** - Project Hindsight founder, translator of ancient texts

            Special thanks to Chris Brennan for preserving and teaching these ancient techniques to modern practitioners.

            ---

            ## 📚 Primary Ancient Sources

            All techniques in HERMES are based on authentic ancient texts:

            ### Hellenistic Era (1st-7th century CE)
            - **Vettius Valens** (*Anthology*, 2nd century CE) - Our primary source for profections, zodiacal releasing, and lots
            - **Claudius Ptolemy** (*Tetrabiblos*, 2nd century CE) - Theoretical foundations of essential dignities and sect
            - **Dorotheus of Sidon** (*Carmen Astrologicum*, 1st century CE) - Early treatment of time-lord techniques
            - **Paulus Alexandrinus** (*Introductory Matters*, 4th century CE) - Teaching manual with profections
            - **Firmicus Maternus** (*Mathesis*, 4th century CE) - Late Hellenistic synthesis
            - **Rhetorius of Egypt** (6th-7th century CE) - Compilation and commentary on earlier authors

            ### Modern Translations & Commentary
            - **Robert Schmidt** - Project Hindsight translations from Greek and Latin
            - **Chris Brennan** - *Hellenistic Astrology: The Study of Fate and Fortune* (2017) - Comprehensive modern synthesis
            - **Demetra George** - *Ancient Astrology in Theory and Practice* (2019) - Practical application guide

            ### Technique Sources
            - **Domicile, Exaltation, Triplicity** → Ptolemy (*Tetrabiblos* I.17-21), Valens (*Anthology* passim)
            - **Egyptian Bounds** → Preserved in Valens and Paulus (distinct from Ptolemy's system)
            - **Decans (Faces)** → Attributed to Egyptian sources, preserved by Hellenistic authors
            - **Lots (Fortune, Spirit)** → Valens (*Anthology* III, IV), Paulus (*Introductory Matters*)
            - **Annual Profections** → Valens (*Anthology* IV), Paulus (*Introductory Matters* 23)
            - **Zodiacal Releasing** → Valens (*Anthology* IV.4-11) - detailed treatment of "Loosing of the Bond"
            - **Sect Theory** → Valens (*Anthology* III.2), Ptolemy (*Tetrabiblos* III.2)

            ### Why These Sources Matter
            Unlike modern psychological astrology, Hellenistic astrology is a **reconstructed tradition** based on
            ancient texts that were lost for centuries. Thanks to Project Hindsight (1990s-2000s) and modern scholars,
            we can now practice astrology as the Greeks and Romans did - with time-lord techniques, essential dignities,
            and a focus on prediction rather than personality.

            HERMES aims to make these authentic ancient techniques accessible through modern AI technology.

            ---

            *Built with ❤️ for traditional astrology and the MCP Birthday Hackathon*

            *"The stars incline, they do not compel" - Traditional maxim*
            """)
    
    return demo

# Launch the app
if __name__ == "__main__":
    demo = create_demo()
    demo.launch()