CircuitNotion AI API - OpenAI SDK Compatible

# Install the official OpenAI Python SDK
pip install openai

# Verify installation
python -c "import openai; print('OpenAI SDK installed successfully')"

from openai import OpenAI

# Initialize client with CircuitNotion base URL and API key
client = OpenAI(
    base_url="https://api.circuitnotion.com/v1",
    api_key="your_api_key_here"
)

# Generate content using circuit-2-turbo model
response = client.chat.completions.create(
    model="circuit-2-turbo",
    messages=[
        {"role": "user", "content": "Explain simply how to beat procrastination"}
    ],
    temperature=0.7,
    max_tokens=200
)

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

# Advanced content generation with custom parameters
response = client.chat.completions.create(
    model="circuit-2-turbo",
    messages=[
        {"role": "system", "content": "You are an expert Python programmer."},
        {"role": "user", "content": "Write a Python function to calculate fibonacci numbers"}
    ],
    temperature=0.3,  # Lower temperature for more focused output
    max_tokens=500,
    top_p=0.9,       # Nucleus sampling
    frequency_penalty=0.1,
    presence_penalty=0.1
)

print("Generated Code:")
print(response.choices[0].message.content)
print(f"Tokens used: {response.usage.total_tokens}")
print(f"Completion tokens: {response.usage.completion_tokens}")

# Multi-turn conversation with message history
messages = [
    {"role": "system", "content": "You are a helpful coding assistant."},
    {"role": "user", "content": "What are the main principles of clean code?"}
]

# First message
response1 = client.chat.completions.create(
    model="circuit-2-turbo",
    messages=messages
)
assistant_reply = response1.choices[0].message.content
print("AI:", assistant_reply)

# Add assistant's response to history
messages.append({"role": "assistant", "content": assistant_reply})

# Follow-up question
messages.append({
    "role": "user", 
    "content": "Can you give me a specific example of the single responsibility principle?"
})

response2 = client.chat.completions.create(
    model="circuit-2-turbo",
    messages=messages
)
print("AI:", response2.choices[0].message.content)

# Full conversation history is in messages list
for msg in messages:
    print(f"{msg['role']}: {msg['content'][:50]}...")

# Streaming responses for real-time generation
print("AI Response: ", end="", flush=True)

stream = client.chat.completions.create(
    model="circuit-2-turbo",
    messages=[
        {"role": "user", "content": "Write a detailed explanation of machine learning concepts"}
    ],
    temperature=0.7,
    max_tokens=1000,
    stream=True  # Enable streaming
)

full_response = ""
for chunk in stream:
    if chunk.choices[0].delta.content:
        content = chunk.choices[0].delta.content
        full_response += content
        print(content, end="", flush=True)

print(f"\n\nComplete response length: {len(full_response)} characters")

# Stream with error handling
try:
    for chunk in client.chat.completions.create(
        model="circuit-2-turbo",
        messages=[{"role": "user", "content": "Explain quantum computing"}],
        stream=True
    ):
        if chunk.choices[0].delta.content:
            print(chunk.choices[0].delta.content, end="", flush=True)
except Exception as e:
    print(f"\nStreaming error: {e}")

# Function calling / Tools support
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the current weather for a location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city and country, e.g. London, UK"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "Temperature unit"
                    }
                },
                "required": ["location"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="circuit-2-turbo",
    messages=[
        {"role": "user", "content": "What's the weather like in Kigali?"}
    ],
    tools=tools,
    tool_choice="auto"  # Let the model decide when to use tools
)

# Check if the model wants to call a function
if response.choices[0].message.tool_calls:
    tool_call = response.choices[0].message.tool_calls[0]
    function_name = tool_call.function.name
    function_args = json.loads(tool_call.function.arguments)
    
    print(f"Function to call: {function_name}")
    print(f"Arguments: {function_args}")
    
    # Call your actual function here and send result back
    # function_result = get_weather(**function_args)
    # Then continue the conversation with the function result

# Process multiple prompts efficiently
import concurrent.futures

prompts = [
    "Explain artificial intelligence in one paragraph",
    "What are the benefits of renewable energy?",
    "How does blockchain technology work?",
    "Describe the importance of cybersecurity"
]

def generate_response(prompt):
    response = client.chat.completions.create(
        model="circuit-2-turbo",
        messages=[{"role": "user", "content": prompt}],
        temperature=0.7,
        max_tokens=150
    )
    return {
        "prompt": prompt,
        "response": response.choices[0].message.content,
        "tokens": response.usage.total_tokens
    }

# Process in parallel using ThreadPoolExecutor
with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
    results = list(executor.map(generate_response, prompts))

for i, result in enumerate(results):
    print(f"\nPrompt {i+1}: {result['prompt']}")
    print(f"Response: {result['response']}")
    print(f"Tokens: {result['tokens']}")
    print("-" * 50)

# Working with different CircuitNotion models
# All models are accessed through the same OpenAI SDK interface

# General-purpose model
response = client.chat.completions.create(
    model="circuit-2-turbo",
    messages=[{"role": "user", "content": "Explain machine learning"}]
)

# For code generation (use lower temperature)
code_response = client.chat.completions.create(
    model="circuit-2-turbo",
    messages=[
        {"role": "system", "content": "You are an expert programmer."},
        {"role": "user", "content": "Create a REST API using FastAPI with authentication"}
    ],
    temperature=0.2,  # Lower temperature for precise code
    max_tokens=800
)

# For creative writing (use higher temperature)
story_response = client.chat.completions.create(
    model="circuit-2-turbo",
    messages=[
        {"role": "system", "content": "You are a creative science fiction writer."},
        {"role": "user", "content": "Write a short story about AI and humanity"}
    ],
    temperature=0.9,  # Higher temperature for creativity
    max_tokens=1000
)

# List available models
models = client.models.list()
for model in models.data:
    print(f"Model: {model.id}")

from openai import OpenAI, OpenAIError, APIError, RateLimitError, AuthenticationError

client = OpenAI(
    base_url="https://api.circuitnotion.com/v1",
    api_key="your_api_key_here"
)
try:
    response = client.chat.completions.create(
        model="circuit-2-turbo",
        messages=[
            {"role": "user", "content": "Generate a creative story"}
        ],
        temperature=0.8,
        max_tokens=500
    )
    print(response.choices[0].message.content)
    
except AuthenticationError as e:
    print("Error: Invalid API key. Please check your credentials.")
    print(f"Details: {e}")
    
except RateLimitError as e:
    print(f"Rate limit exceeded. Please try again later.")
    print(f"Details: {e}")
    
except APIError as e:
    print(f"API Error: {e}")
    print(f"Status code: {e.status_code}")
    
except OpenAIError as e:
    print(f"OpenAI SDK Error: {e}")
    
except Exception as e:
    print(f"Unexpected error: {str(e)}")

# Configuration management
import os
from openai import OpenAI

# Basic configuration
client = OpenAI(
    base_url="https://api.circuitnotion.com/v1",
    api_key=os.getenv("CIRCUITNOTION_API_KEY"),  # From environment
    timeout=30.0,  # Request timeout in seconds
    max_retries=3  # Automatic retries
)

# Advanced configuration with custom headers
from openai import DefaultHttpxClient
import httpx

http_client = DefaultHttpxClient(
    timeout=60.0,
    limits=httpx.Limits(max_keepalive_connections=5, max_connections=10)
)

client = OpenAI(
    base_url="https://api.circuitnotion.com/v1",
    api_key=os.getenv("CIRCUITNOTION_API_KEY"),
    http_client=http_client,
    default_headers={
        "X-Custom-Header": "value"
    }
)

# Async client for async operations
from openai import AsyncOpenAI

async_client = AsyncOpenAI(
    base_url="https://api.circuitnotion.com/v1",
    api_key=os.getenv("CIRCUITNOTION_API_KEY")
)

# Use in async function
async def generate_async():
    response = await async_client.chat.completions.create(
        model="circuit-2-turbo",
        messages=[{"role": "user", "content": "Hello!"}]
    )
    return response.choices[0].message.content