Sunflower API Documentation¶

import requests
import json

def chat_with_sunflower(messages, api_key, base_url="https://api.sunbird.ai"):
    """
    Send a chat completion request to Sunflower API
    """
    url = f"{base_url}/tasks/sunflower_inference"

    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }

    payload = {
        "messages": messages,
        "model_type": "qwen",
        "temperature": 0.3,
        "stream": False
    }

    try:
        response = requests.post(url, headers=headers, json=payload, timeout=30)
        response.raise_for_status()
        return response.json()

    except requests.exceptions.RequestException as e:
        print(f"Request failed: {e}")
        return None

# Example usage
api_key = "your_api_key_here"

messages = [
    {
        "role": "system", 
        "content": "You are Sunflower, a multilingual assistant for Ugandan languages made by Sunbird AI."
    },
    {
        "role": "user", 
        "content": "Translate 'Good morning' to Luganda"
    }
]

result = chat_with_sunflower(messages, api_key)
if result:
    print(f"Response: {result['content']}")
    print(f"Tokens used: {result['usage']['total_tokens']}")

import requests

def simple_inference(instruction, api_key, base_url="https://api.sunbird.ai"):
    """
    Send a simple inference request to Sunflower API
    """
    url = f"{base_url}/tasks/sunflower_simple"

    headers = {
        "Authorization": f"Bearer {api_key}"
    }

    data = {
        "instruction": instruction,
        "model_type": "qwen",
        "temperature": 0.3
    }

    try:
        response = requests.post(url, headers=headers, data=data, timeout=30)
        response.raise_for_status()
        return response.json()

    except requests.exceptions.RequestException as e:
        print(f"Request failed: {e}")
        return None

# Example usage
api_key = "your_api_key_here"
instruction = "Explain the meaning of 'Ubuntu' in Ugandan context"

result = simple_inference(instruction, api_key)
if result:
    print(f"Response: {result['response']}")

class SunflowerConversation:
    def __init__(self, api_key, base_url="https://api.sunbird.ai"):
        self.api_key = api_key
        self.base_url = base_url
        self.messages = []

    def set_system_message(self, message):
        """Set or update the system message"""
        # Remove existing system message
        self.messages = [msg for msg in self.messages if msg["role"] != "system"]
        # Add new system message at the beginning
        self.messages.insert(0, {"role": "system", "content": message})

    def add_user_message(self, content):
        """Add a user message to the conversation"""
        self.messages.append({"role": "user", "content": content})

    def get_response(self, model_type="qwen", temperature=0.3):
        """Get AI response and add it to conversation"""
        url = f"{self.base_url}/tasks/sunflower_inference"

        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }

        payload = {
            "messages": self.messages,
            "model_type": model_type,
            "temperature": temperature
        }

        try:
            response = requests.post(url, headers=headers, json=payload, timeout=30)
            response.raise_for_status()
            result = response.json()

            # Add assistant response to conversation
            self.messages.append({
                "role": "assistant", 
                "content": result["content"]
            })

            return result

        except requests.exceptions.RequestException as e:
            print(f"Request failed: {e}")
            return None

    def clear_conversation(self):
        """Clear conversation history but keep system message"""
        system_messages = [msg for msg in self.messages if msg["role"] == "system"]
        self.messages = system_messages

# Example usage
conversation = SunflowerConversation("your_api_key_here")

# Set system message
conversation.set_system_message(
    "You are Sunflower, a helpful assistant specializing in Ugandan languages and culture."
)

# Have a conversation
conversation.add_user_message("Hello, can you greet me in Luganda?")
response1 = conversation.get_response()
print(f"AI: {response1['content']}")

conversation.add_user_message("How do I say 'thank you' in Acholi?")
response2 = conversation.get_response()
print(f"AI: {response2['content']}")

import time
import random
from typing import Optional

def sunflower_request_with_retry(
    messages, 
    api_key, 
    max_retries=3,
    base_delay=2.0,
    base_url="https://api.sunbird.ai"
) -> Optional[dict]:
    """
    Make a request to Sunflower API with exponential backoff retry
    """
    url = f"{base_url}/tasks/sunflower_inference"

    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }

    payload = {
        "messages": messages,
        "model_type": "qwen",
        "temperature": 0.3
    }

    for attempt in range(max_retries + 1):
        try:
            response = requests.post(url, headers=headers, json=payload, timeout=30)

            if response.status_code == 200:
                return response.json()

            elif response.status_code == 503:
                # Model loading - retry with longer delay
                if attempt < max_retries:
                    delay = base_delay * (2 ** attempt) + random.uniform(0, 1)
                    print(f"Model loading, retrying in {delay:.1f} seconds...")
                    time.sleep(delay)
                    continue

            elif response.status_code == 429:
                # Rate limited - retry with exponential backoff
                if attempt < max_retries:
                    delay = base_delay * (2 ** attempt)
                    print(f"Rate limited, retrying in {delay:.1f} seconds...")
                    time.sleep(delay)
                    continue

            else:
                print(f"Request failed with status {response.status_code}: {response.text}")
                return None

        except requests.exceptions.Timeout:
            if attempt < max_retries:
                delay = base_delay * (2 ** attempt)
                print(f"Request timed out, retrying in {delay:.1f} seconds...")
                time.sleep(delay)
                continue
            else:
                print("Request timed out after all retries")
                return None

        except requests.exceptions.RequestException as e:
            print(f"Request failed: {e}")
            return None

    print("All retry attempts exhausted")
    return None

# Example usage
messages = [
    {"role": "user", "content": "What is the capital of Uganda?"}
]

result = sunflower_request_with_retry(messages, "your_api_key_here")
if result:
    print(f"Response: {result['content']}")