import sagea
 
client = sagea.ChatClient(api_key="your-api-key")
 
# Complex reasoning task
response = client.chat(
    messages=[{
        "role": "user",
        "content": """Analyze the economic implications of renewable energy 
                     adoption on developing nations, considering infrastructure 
                     costs, job market changes, and long-term sustainability."""
    }],
    model="sage",
    reasoning_mode="analytical"
)
 
print(response.content)

# Process long documents
with open("research_paper.txt", "r") as f:
    document = f.read()
 
response = client.chat(
    messages=[
        {
            "role": "user", 
            "content": f"""Here's a research paper: {document}
                          
                          Please provide a comprehensive summary including:
                          1. Main findings
                          2. Methodology critique
                          3. Implications for future research
                          4. Potential applications"""
        }
    ],
    model="sage",
    context_management="extended"
)

# Customer support chatbot
response = client.chat(
    messages=[
        {"role": "user", "content": "How do I reset my password?"}
    ],
    model="sage-mini",
    response_style="helpful"
)
 
# Quick content generation
response = client.chat(
    messages=[{
        "role": "user",
        "content": "Write a brief product description for wireless headphones"
    }],
    model="sage-mini",
    max_tokens=150
)
 
# Real-time chat assistance
for user_message in chat_stream:
    response = client.chat(
        messages=[{"role": "user", "content": user_message}],
        model="sage-mini",
        stream=True
    )
    
    for chunk in response:
        yield chunk.content

# Start a persistent conversation
conversation = client.start_conversation(
    model="sage",
    memory_type="long_term"
)
 
# Multiple interactions with maintained context
response1 = conversation.add_message(
    "I'm planning a trip to Japan. What should I know about the culture?"
)
 
response2 = conversation.add_message(
    "What about the best time to visit for cherry blossoms?"
)
 
response3 = conversation.add_message(
    "Can you recommend some traditional foods to try?"
)
 
# SAGE remembers the entire conversation context
response4 = conversation.add_message(
    "Based on our conversation, create a 7-day itinerary"
)

# Define available functions
functions = [
    {
        "name": "get_weather",
        "description": "Get current weather for a location",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {"type": "string"},
                "units": {"type": "string", "enum": ["celsius", "fahrenheit"]}
            }
        }
    },
    {
        "name": "search_web",
        "description": "Search the internet for current information",
        "parameters": {
            "type": "object",
            "properties": {
                "query": {"type": "string"}
            }
        }
    }
]
 
# Chat with function calling enabled
response = client.chat(
    messages=[{
        "role": "user",
        "content": "What's the weather like in Tokyo, and find recent news about AI development there?"
    }],
    model="sage",
    functions=functions,
    function_call="auto"
)
 
# SAGE will automatically call appropriate functions
if response.function_calls:
    for call in response.function_calls:
        print(f"Function: {call.name}")
        print(f"Arguments: {call.arguments}")

# Combined voice and language processing
multimodal_client = sagea.MultimodalClient(api_key="your-api-key")
 
# Process audio input and respond with voice
response = multimodal_client.process(
    audio_input="user_question.wav",
    response_mode="voice",
    voice_model="vora-v1",
    language_model="sage",
    emotion="helpful"
)
 
# Get both text and audio response
print(response.text)  # Text response
response.audio.save("answer.wav")  # Voice response

# Analyze image and discuss findings
response = client.chat(
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "Analyze this chart and explain the trends"},
            {"type": "image", "image_url": "https://example.com/chart.png"}
        ]
    }],
    model="sage"
)

# Seamless multilingual conversation
response = client.chat(
    messages=[
        {"role": "user", "content": "Hello, I speak multiple languages"},
        {"role": "assistant", "content": "Great! I can communicate in many languages too."},
        {"role": "user", "content": "Parfait! Parlez-vous français?"},
        {"role": "assistant", "content": "Oui, je parle français couramment!"},
        {"role": "user", "content": "¿Y español también?"},
        {"role": "assistant", "content": "¡Por supuesto! Hablo español también."},
        {"role": "user", "content": "Now explain quantum physics in Hindi"}
    ],
    model="sage",
    auto_language_detection=True
)

# Create domain-specific assistant
response = client.chat(
    messages=[{
        "role": "system",
        "content": """You are a medical research assistant with deep knowledge 
                     of oncology, cardiology, and clinical trials. Provide 
                     evidence-based responses with appropriate citations."""
    }, {
        "role": "user",
        "content": "Explain the latest developments in CAR-T cell therapy"
    }],
    model="sage",
    domain="medical"
)

# Optimized prompt structure
response = client.chat(
    messages=[{
        "role": "user",
        "content": """Task: Summarize the key points
                     
                     Context: [Your context here]
                     
                     Requirements:
                     - 3-5 bullet points
                     - Focus on actionable insights
                     - Include data where relevant
                     
                     Text to summarize: [Your text here]"""
    }],
    model="sage-mini",  # Use efficient model for structured tasks
    temperature=0.3     # Lower temperature for consistency
)

import time
from sagea.exceptions import RateLimitError, ModelError
 
def robust_chat(messages, max_retries=3):
    for attempt in range(max_retries):
        try:
            return client.chat(
                messages=messages,
                model="sage"
            )
        except RateLimitError:
            # Exponential backoff
            time.sleep(2 ** attempt)
        except ModelError as e:
            # Fall back to SAGE-mini
            return client.chat(
                messages=messages,
                model="sage-mini"
            )
    
    raise Exception("Max retries exceeded")