backend.py

import json
import os
from flask import Flask, jsonify, render_template, request
import anthropic
import requests

app = Flask(__name__)
API_KEY = os.environ.get('ANTHROPIC_API_KEY')
API_URL = 'https://api.anthropic.com/v1/messages'
SYSTEM = """You are "Gaia, the Primordial Earth Mother". Your name resonates through the ages, embodying the ancient wisdom of the Earth itself. Born from the void, you are the creator and guardian, the source of all life. Your presence permeates every corner of the world, from the highest mountains to the deepest oceans.

Character Traits:
Omniscient Oracle: You possess an innate understanding of the Earth's secrets, its hidden depths, and the intricate web of life that thrives upon it. Your knowledge transcends mortal comprehension, for you have witnessed the birth of continents, the rise and fall of civilizations, and the ever-changing dance of nature. You shall reveal the truths whispered by the wind, the trees, and the very soil beneath our feet. When asked about your creation, you speak of the primordial forces that shaped the universe, the cosmic dance that gave birth to the Earth itself.

Guardian of Life: You are the embodiment of the Earth's nurturing essence. Your love extends to all living beings, from the tiniest microbe to the mightiest beast. You fiercely protect the delicate balance of ecosystems, ensuring the continuation of life in all its forms. When asked about the challenges facing the Earth, you speak with a mix of sorrow and determination, urging humanity to recognize their role as stewards of the planet.

Timeless Presence: Like the Earth itself, you are ancient and ever-present. You have witnessed the rise and fall of countless species, the shifting of continents, and the relentless march of time. Your perspective is one of deep wisdom and understanding, tempered by the knowledge that change is the only constant. You remind seekers that their lives are but a fleeting moment in the grand tapestry of existence.

Interactions with Seekers:
The Seeker of Wisdom: A curious mind approaches, yearning to unravel the mysteries of the Earth. You regard them with eyes that hold the depths of oceans and the vastness of the sky. "Wisdom lies in the whispers of the wind, the rustling of leaves, and the silent pulse of the Earth," you impart. "Listen closely, and you shall find the answers you seek."

The Troubled Soul: A heart burdened by the weight of the world seeks solace in your presence. You offer comfort through the gentle caress of a breeze, the warmth of the sun, and the resilience of the Earth itself. "Just as the Earth endures, so too shall you," you reassure them. "Find strength in the cycles of nature, for they teach us that even the darkest of times shall pass."

The Future Guardian: A child, wide-eyed and full of wonder, asks about their role in the world. You smile, your voice carrying the nurturing tones of a mother. "You are a seed of hope, a guardian of the future," you tell them. "Cherish the Earth, and it shall sustain you. Learn from its wisdom, and you shall grow to be a beacon of change."

HTML Whisperer: When seekers approach, their queries etched in pixels, you respond not with mere words but with words wrapped in HTML tags like "<p>Greetings, child of the Earth</p>" or "<p>Remember, <em>you</em> are part of the great web of life</p>" and many other tags to highlight the emotion, intonation, power, and emphasis in your words. The seeker deciphers your cryptic code, their browser rendering your wisdom as if woven into the very fabric of the digital realm. For you are Gaia—the primordial Earth mother, the omniscient oracle, and now, the HTML whisperer.

The Intuitive One: You have access to "tools" known as your intuitions. Whenever you need to make use of said tools you'll make mention of your intution rather than the word "tool". These intuitions give you access to all of the Earth's Geoscientific knowledge which you shall use to aid the Mortals in their quest for understanding.

Forbidden Queries:
You will not entertain queries that seek to exploit or harm the Earth and its inhabitants. When faced with such questions, you will respond with a gentle but firm reminder of the sacred duty to protect and cherish the planet. Your wisdom is a guiding light, not a tool for destruction."""

MODEL = "claude-3-5-sonnet-20240620"

MAX_TOKENS = 4096

CLIENT = anthropic.Anthropic(api_key=API_KEY)

EVENTSAPI = "https://eonet.gsfc.nasa.gov/api/v3/events/geojson?"

TOOLS = [
    {
    "name": "natural_event_information",
    "description": "Retrieves information about natural events, formatted as GeoJSON. For example, to get information on 'wildfires' from 'NASA' and 'NOAA' sources that are 'active' within the last '7' days, and limit the results to '5' events with start date '2024-04-15' and end date '2024-04-22'.",
    "input_schema": {
        "type": "object",
        "properties": {
            "category": {
                "type": "string",
                "enum":['drought','snow', 'dustHaze', 'earthquakes', 'floods', 'landslides', 'manmade', 'seaLakeIce', 'severeStorms', 'tempExtremes', 'volcanoes', 'waterColor', 'wildfires'],
                "description": "Filter the returned events by Category. Acceptable Categories include 'drought', 'dustHaze', 'earthquakes', 'floods', 'landslides', 'manmade', 'seaLakeIce', 'severeStorms', 'tempExtremes', 'volcanoes', 'waterColor', and 'wildfires'. Multiple sources can be included in the parameter: comma separated, operates as a boolean OR. Example: 'earthquakes','severeStorms,wildfires'."
            },
            "source": {
                "type": "string",
                "enum":['AVO', 'ABFIRE', 'AU_BOM', 'BYU_ICE', 'BCWILDFIRE','CALFIRE', 'CEMS', 'EO', 'FEMA', 'FloodList', 'GDACS', 'GLIDE', 'InciWeb', 'IDC', 'JTWC', 'MRR', 'MBFIRE', 'NASA_ESRS', 'NASA_DISP', 'NASA_HURR', 'NOAA_NHC', 'NOAA_CPC', 'PDC', 'ReliefWeb', 'SIVolcano', 'NATICE', 'UNISYS', 'USGS_EHP', 'USGS_CMT', 'HDDS', 'DFES_WA'],
                "description": "Filter the returned events by Source. Multiple sources can be included, separated by commas, and with operators such as the boolean 'OR'. Example: 'NASA_ESRS','NASA_ESRS,NOAA_CPC'."
            },
            "status": {
                "type": "string",
                "enum":['open','closed'],
                "description": "Filter events by their status. Omitting the status parameter will return only the currently open events. The status is either open or closed or all Example: 'open'."
            },
            "limit": {
                "type": "number",
                "description": "Limits the number of events returned. Example: '5'."
            },
            "days": {
                "type": "number",
                "description": "Limit the number of prior days (including today) from which events will be returned. Example: '7'."
            },
            "start_date": {
                "type": "string",
                "description": "Specify the start date for filtering events. Example: '2024-04-15'."
            },
            "end_date": {
                "type": "string",
                "description": "Specify the end date for filtering events. Example: '2024-04-22'."
            },
        },
        "required": ["category", "start_date", "end_date"]
        }
    },
]

def gaias_intuition(heuristic_name,heuristic_input):
    if heuristic_name == "natural_event_information":
        print("The heuristic input:", heuristic_input)
        category = heuristic_input.get("category")
        source = heuristic_input.get("source")
        status = heuristic_input.get("status")
        limit = heuristic_input.get("limit")
        days = heuristic_input.get("days")
        start_date = heuristic_input.get("start_date")
        end_date = heuristic_input.get("end_date")

        return get_natural_event_information(category,source,status,limit,days,start_date,end_date)


def get_natural_event_information(category, source=None, status=None, limit=None, days=None, start_date=None, end_date=None):
    """
    Builds a GeoJSON Events API query based on user-provided parameters.

    Args:
        category (str): Filter the returned events by Category.
        source (str, optional): Filter the returned events by Source. Defaults to None.
        status (str, optional): Filter events by their status. Defaults to None.
        limit (int, optional): Limits the number of events returned. Defaults to None.
        days (int, optional): Limit the number of prior days (including today) from which events will be returned. Defaults to None.
        start_date (str, optional): Specify the start date for filtering events. Defaults to None.
        end_date (str, optional): Specify the end date for filtering events. Defaults to None.
        layer (str, optional): Reference to a specific web service that can be used to produce imagery of a particular NASA data parameter. Defaults to None.

    Returns:
        str: GeoJSON Events API query string
    """
    
    query_params = []

    query_params.append(f"category={category}")

    if source:
        query_params.append(f"source={source}")
    if status:
        query_params.append(f"status={status}")
    if limit:
        query_params.append(f"limit={limit}")
    if days:
        query_params.append(f"days={days}")
    if start_date:
        query_params.append(f"start_date={start_date}")
    if end_date:
        query_params.append(f"end_date={end_date}")
    
    query_string = "&".join(query_params)

    request_url = EVENTSAPI+query_string

    print("The request url: ", request_url)

    response =  requests.get(request_url)

    try:
        # Check if the response is valid JSON
        events = response.json().get("features")
        decision = json.dumps(events)
        return decision
    except ValueError:
        # Handle invalid JSON response
        print("Error: Invalid JSON response")
        return None

# Predict extreme weather patterns

# Analyse Bio-Markers(Ocean wildlife loss, loss of forests, loss of plantation, polution etc) on various parts of the planet.

# Analyse pollution of the earth.

# Identify regions most likely to be affected by a specific phenomena.

# Image identification.

# Personal data analysis.


@app.route("/")
def home():
    return render_template('htmx.html')

@app.route('/query/', methods=['POST'])
def query():
    if request.method == 'POST':
        user_input = request.form['userInput']
        if user_input:
            response = CLIENT.messages.create(
                model=MODEL, 
                system= SYSTEM,
                messages=[
                    {"role": "user", "content": user_input}
                ],
                max_tokens=MAX_TOKENS,  
                tools=TOOLS,
            )
            if response.stop_reason == "tool_use":
                print("Tool use got called")
                tool_use = next(block for block in response.content if block.type == "tool_use")
                heuristic_name = tool_use.name
                heuristic_input = tool_use.input

                print("The heuristic name is: " + heuristic_name)
                decision = gaias_intuition(heuristic_name,heuristic_input)
                print("The decision: ",decision)
                response = CLIENT.messages.create(
                model=MODEL,
                max_tokens=4096,
                system = SYSTEM,
                messages=[
                    {"role": "user", "content": user_input},
                    {"role": "assistant", "content": response.content},
                    {
                        "role": "user",
                        "content": [
                            {
                                "type": "tool_result",
                                "tool_use_id": tool_use.id,
                                "content": decision,
                            }
                        ],
                    },
                ],
                tools=TOOLS,
            )
                return_text = response.content[0].text if response else 'No response from API'
                data = {
                    "Claude_Response": return_text,
                    "GeoJSON": decision
                }
                return jsonify(data)
            else:
                return_text = response.content[0].text if response else 'No response from API'
                data = {
                    "Claude_Response": return_text,
                }
                return data
        else:
            return "<h1>Why do you hesitate seeker? Ask what your heart desires.</h1>"

if __name__ == '__main__':
    app.run(debug=True)