Python SDK

from rax_ai import RaxAI

# Initialize the client
client = RaxAI(api_key="rax_your_api_key")

# Make your first request
response = client.chat(
    model="rax-4.0",
    messages=[
        {"role": "user", "content": "Hello, how are you?"}
    ]
)

print(response.choices[0].message.content)

from rax_ai import RaxAI

client = RaxAI(api_key="rax_your_api_key")

# Simple chat completion
response = client.chat(
    model="rax-4.0",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "What is the capital of France?"}
    ],
    temperature=0.7,
    max_tokens=1000
)

# Get the response
print(response.choices[0].message.content)
# Output: "The capital of France is Paris."

# Access usage information
print(f"Tokens used: {response.usage.total_tokens}")

from rax_ai import RaxAI

client = RaxAI(api_key="rax_your_api_key")

# Stream responses in real-time
stream = client.chat_stream(
    model="rax-4.5",
    messages=[
        {"role": "user", "content": "Write a short poem about Python."}
    ]
)

# Process chunks as they arrive
for chunk in stream:
    content = chunk.choices[0].delta.content
    if content:
        print(content, end="", flush=True)

print()  # New line at the end

import asyncio
from rax_ai import AsyncRaxAI

async def main():
    # Initialize async client
    client = AsyncRaxAI(api_key="rax_your_api_key")
    
    # Async chat completion
    response = await client.chat(
        model="rax-4.0",
        messages=[
            {"role": "user", "content": "Hello!"}
        ]
    )
    print(response.choices[0].message.content)
    
    # Async streaming
    stream = await client.chat_stream(
        model="rax-4.5",
        messages=[
            {"role": "user", "content": "Tell me a joke."}
        ]
    )
    
    async for chunk in stream:
        content = chunk.choices[0].delta.content
        if content:
            print(content, end="", flush=True)
    
    # Don't forget to close the client
    await client.close()

# Run the async function
asyncio.run(main())

from rax_ai import RaxAI

client = RaxAI(api_key="rax_your_api_key")

# Maintain conversation history
messages = [
    {"role": "system", "content": "You are a helpful coding assistant."}
]

def chat(user_message: str) -> str:
    """Send a message and get a response, maintaining history."""
    # Add user message
    messages.append({"role": "user", "content": user_message})
    
    # Get response
    response = client.chat(
        model="rax-4.5",
        messages=messages
    )
    
    assistant_message = response.choices[0].message.content
    
    # Add to history for context
    messages.append({"role": "assistant", "content": assistant_message})
    
    return assistant_message

# Multi-turn conversation
print(chat("How do I read a file in Python?"))
print(chat("What about handling exceptions?"))
print(chat("Can you show me a complete example?"))

from rax_ai import RaxAI, RaxAIError, RateLimitError, AuthError

client = RaxAI(api_key="rax_your_api_key")

try:
    response = client.chat(
        model="rax-4.0",
        messages=[{"role": "user", "content": "Hello!"}]
    )
    print(response.choices[0].message.content)

except RateLimitError as e:
    print(f"Rate limited. Retry after {e.retry_after} seconds")
    # Implement exponential backoff
    
except AuthError as e:
    print("Invalid API key. Please check your credentials.")
    
except RaxAIError as e:
    # Catch all Rax AI errors
    print(f"API Error: {e.message}")
    print(f"Status: {e.status_code}")
    print(f"Code: {e.error_code}")
    
except Exception as e:
    # Network or other errors
    print(f"Unexpected error: {e}")

from rax_ai import RaxAI
from rax_ai.types import (
    ChatMessage,
    ChatResponse,
    StreamChunk,
    Model,
    Usage
)

# Type-annotated client
client: RaxAI = RaxAI(api_key="rax_your_api_key")

# Type-safe messages
messages: list[ChatMessage] = [
    {"role": "system", "content": "You are helpful."},
    {"role": "user", "content": "Hello!"}
]

# Type-safe response
response: ChatResponse = client.chat(
    model="rax-4.0",
    messages=messages
)

# Access typed properties
content: str = response.choices[0].message.content
usage: Usage = response.usage
tokens: int = usage.total_tokens

# Type-safe streaming
from typing import Iterator

stream: Iterator[StreamChunk] = client.chat_stream(
    model="rax-4.5",
    messages=messages
)

for chunk in stream:
    delta_content: str | None = chunk.choices[0].delta.content

from rax_ai import RaxAI, AsyncRaxAI

# Sync Client
client = RaxAI(
    api_key: str,           # Your API key (required)
    base_url: str = None,   # Custom API URL (optional)
    timeout: float = 30.0,  # Request timeout in seconds
    max_retries: int = 2,   # Auto-retry count
)

# Methods
client.chat(...)           # Chat completion
client.chat_stream(...)    # Streaming chat
client.models()            # List models
client.usage()             # Get usage stats

# Async Client
async_client = AsyncRaxAI(
    api_key: str,
    base_url: str = None,
    timeout: float = 30.0,
    max_retries: int = 2,
)

# Async Methods
await async_client.chat(...)
await async_client.chat_stream(...)
await async_client.models()
await async_client.usage()
await async_client.close()  # Clean up