SDKs & Libraries

BlueNexus AI provides official SDKs for popular programming languages to make it easy to integrate with our platform.

Official SDKs

Python SDK

The official Python SDK provides a simple interface to the BlueNexus AI API.

Installation

pip install bluenexus

Quick Start

import bluenexus

# Initialize the client
client = bluenexus.Client(api_key="YOUR_API_KEY")

# Create a data record
task = client.data.create("tasks", {
    "title": "Learn AI development",
    "description": "Study machine learning concepts",
    "priority": 3
})

# Get data records
tasks = client.data.list("tasks", filters={"priority": {"$gte": 3}})

# Use LLM services
response = client.llm.create_completion(
    model="gpt-3.5-turbo",
    messages=[
        {"role": "user", "content": "Explain quantum computing"}
    ]
)

Advanced Usage

import bluenexus
from bluenexus.auth import OAuthClient

# OAuth authentication
client = OAuthClient(
    client_id="YOUR_CLIENT_ID",
    client_secret="YOUR_CLIENT_SECRET",
    redirect_uri="https://yourapp.com/callback"
)

# Get authorization URL
auth_url = client.get_authorization_url()

# Exchange code for tokens
tokens = client.exchange_code("AUTHORIZATION_CODE")

# Use authenticated client
authenticated_client = bluenexus.Client(access_token=tokens["access_token"])

JavaScript/Node.js SDK

The official JavaScript SDK works in both Node.js and browser environments.

Installation

npm install @bluenexus/sdk

Node.js Usage

const { BlueNexusClient } = require('@bluenexus/sdk');

// Initialize the client
const client = new BlueNexusClient({
  apiKey: 'YOUR_API_KEY'
});

// Create a data record
const task = await client.data.create('tasks', {
  title: 'Learn AI development',
  description: 'Study machine learning concepts',
  priority: 3
});

// Get data records
const tasks = await client.data.list('tasks', {
  filters: { priority: { $gte: 3 } }
});

// Use LLM services
const response = await client.llm.createCompletion({
  model: 'gpt-3.5-turbo',
  messages: [
    { role: 'user', content: 'Explain quantum computing' }
  ]
});

Browser Usage

<script src="https://unpkg.com/@bluenexus/sdk@latest/dist/bluenexus.min.js"></script>
<script>
  const client = new BlueNexus.BlueNexusClient({
    apiKey: 'YOUR_API_KEY'
  });

  // Use the client
  client.data.create('tasks', {
    title: 'Learn AI development'
  }).then(task => {
    console.log('Created task:', task);
  });
</script>

Go SDK

The official Go SDK provides type-safe access to the BlueNexus AI API.

Installation

go get github.com/bluenexus/go-sdk

Usage

package main

import (
    "fmt"
    "log"
    "github.com/bluenexus/go-sdk"
)

func main() {
    // Initialize the client
    client := bluenexus.NewClient("YOUR_API_KEY")

    // Create a data record
    task := bluenexus.Task{
        Title:       "Learn AI development",
        Description: "Study machine learning concepts",
        Priority:    3,
    }

    createdTask, err := client.Data.Create("tasks", task)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Created task: %+v\n", createdTask)

    // Get data records
    tasks, err := client.Data.List("tasks", bluenexus.Filters{
        "priority": bluenexus.Filter{"$gte": 3},
    })
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Found %d tasks\n", len(tasks))

    // Use LLM services
    response, err := client.LLM.CreateCompletion(bluenexus.CompletionRequest{
        Model: "gpt-3.5-turbo",
        Messages: []bluenexus.Message{
            {Role: "user", Content: "Explain quantum computing"},
        },
    })
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("AI Response: %s\n", response.Choices[0].Message.Content)
}

Ruby SDK

The official Ruby SDK provides a Ruby-friendly interface to the BlueNexus AI API.

Installation

gem install bluenexus

Usage

require 'bluenexus'

# Initialize the client
client = BlueNexus::Client.new(api_key: 'YOUR_API_KEY')

# Create a data record
task = client.data.create('tasks', {
  title: 'Learn AI development',
  description: 'Study machine learning concepts',
  priority: 3
})

# Get data records
tasks = client.data.list('tasks', filters: { priority: { '$gte' => 3 } })

# Use LLM services
response = client.llm.create_completion(
  model: 'gpt-3.5-turbo',
  messages: [
    { role: 'user', content: 'Explain quantum computing' }
  ]
)

Community Libraries

PHP

composer require bluenexus/php-sdk

<?php
use BlueNexus\Client;

$client = new Client('YOUR_API_KEY');

$task = $client->data->create('tasks', [
    'title' => 'Learn AI development',
    'description' => 'Study machine learning concepts',
    'priority' => 3
]);

$tasks = $client->data->list('tasks', [
    'filters' => ['priority' => ['$gte' => 3]]
]);

Java

<dependency>
    <groupId>ai.bluenexus</groupId>
    <artifactId>bluenexus-java</artifactId>
    <version>1.0.0</version>
</dependency>

import ai.bluenexus.BlueNexusClient;
import ai.bluenexus.models.Task;

BlueNexusClient client = new BlueNexusClient("YOUR_API_KEY");

Task task = new Task();
task.setTitle("Learn AI development");
task.setDescription("Study machine learning concepts");
task.setPriority(3);

Task createdTask = client.data().create("tasks", task);

C#

dotnet add package BlueNexus.SDK

using BlueNexus;

var client = new BlueNexusClient("YOUR_API_KEY");

var task = new Task
{
    Title = "Learn AI development",
    Description = "Study machine learning concepts",
    Priority = 3
};

var createdTask = await client.Data.CreateAsync("tasks", task);

SDK Features

Common Features

All official SDKs provide:

• Type Safety: Strong typing where supported

• Error Handling: Comprehensive error handling

• Retry Logic: Automatic retry with exponential backoff

• Rate Limiting: Built-in rate limit handling

• Authentication: Multiple authentication methods

• Documentation: Comprehensive documentation

• Examples: Code examples and tutorials

Authentication Methods

• API Key: Simple API key authentication

• OAuth 2.0: Full OAuth 2.0 flow support

• Personal Access Tokens: Long-term API access

• JWT Tokens: JSON Web Token support

Data Operations

• CRUD Operations: Create, read, update, delete

• Filtering: Advanced filtering capabilities

• Pagination: Cursor-based pagination

• Validation: Input validation and sanitization

AI Operations

• LLM Services: Language model completions

• Streaming: Real-time streaming responses

• Model Management: Model selection and configuration

• Token Management: Automatic token counting

Configuration

Environment Variables

# API Key
BLUENEXUS_API_KEY=your_api_key_here

# OAuth
BLUENEXUS_CLIENT_ID=your_client_id
BLUENEXUS_CLIENT_SECRET=your_client_secret
BLUENEXUS_REDIRECT_URI=https://yourapp.com/callback

# Configuration
BLUENEXUS_BASE_URL=https://api.bluenexus.ai
BLUENEXUS_TIMEOUT=30
BLUENEXUS_RETRY_ATTEMPTS=3

Client Configuration

const client = new BlueNexusClient({
  apiKey: 'YOUR_API_KEY',
  baseUrl: 'https://api.bluenexus.ai',
  timeout: 30000,
  retryAttempts: 3,
  debug: false
});

Error Handling

Common Error Types

• AuthenticationError: Invalid credentials

• RateLimitError: Rate limit exceeded

• ValidationError: Invalid input data

• NetworkError: Network connectivity issues

• ServerError: Server-side errors

Error Handling Example

import bluenexus
from bluenexus.exceptions import AuthenticationError, RateLimitError

try:
    client = bluenexus.Client(api_key="INVALID_KEY")
    tasks = client.data.list("tasks")
except AuthenticationError:
    print("Invalid API key")
except RateLimitError as e:
    print(f"Rate limit exceeded. Retry after {e.retry_after} seconds")
except Exception as e:
    print(f"Unexpected error: {e}")

Testing

Mock Client

import bluenexus
from bluenexus.testing import MockClient

# Use mock client for testing
client = MockClient()

# Mock responses
client.data.create.return_value = {"id": "test_123", "title": "Test Task"}

# Test your code
task = client.data.create("tasks", {"title": "Test Task"})
assert task["id"] == "test_123"

Test Fixtures

import pytest
import bluenexus

@pytest.fixture
def client():
    return bluenexus.Client(api_key="test_key")

@pytest.fixture
def sample_task():
    return {
        "title": "Test Task",
        "description": "Test Description",
        "priority": 3
    }

Best Practices

Performance

1. Connection Pooling: Reuse HTTP connections

2. Batch Operations: Use batch operations when possible

3. Caching: Cache frequently accessed data

4. Async Operations: Use async/await for better performance

Security

1. Environment Variables: Store API keys in environment variables

2. Token Rotation: Regularly rotate API keys

3. Scope Limitation: Use minimal required scopes

4. Input Validation: Validate all inputs

Error Handling

1. Retry Logic: Implement exponential backoff

2. Circuit Breaker: Use circuit breaker pattern

3. Logging: Log errors for debugging

4. Monitoring: Monitor API usage and errors

Support

Documentation

• API Reference: Complete API documentation

• Code Examples: Comprehensive code examples

• Tutorials: Step-by-step tutorials

• Best Practices: Development best practices

Community

• GitHub: Source code and issue tracking

• Discord: Community support and discussions

• Stack Overflow: Technical questions and answers

• Blog: Latest updates and tutorials

Professional Support

• Enterprise Support: Priority support for enterprise customers

• Training: Custom training sessions

• Consulting: Architecture and implementation consulting

• SLA: Service level agreements

Related Documentation

• Getting Started - Platform setup

• Authentication Guide - Authentication methods

• API Reference - Complete API documentation

• Building Your First App - End-to-end tutorial