Development

pip install requests
pip install python-dotenv  # For environment variables

npm install axios
npm install dotenv  # For environment variables

# cURL is usually pre-installed on most systems
curl --version

import os
import requests
from dotenv import load_dotenv

# Load environment variables
load_dotenv()

class QuantumAPIClient:
    def __init__(self):
        self.base_url = os.getenv('QUANTUM_API_BASE_URL')
        self.token = os.getenv('QUANTUM_API_TOKEN')
        self.headers = {
            'Authorization': f'Bearer {self.token}',
            'Content-Type': 'application/json'
        }
    
    def test_connection(self):
        """Test API connection"""
        try:
            response = requests.get(f'{self.base_url}/test', headers=self.headers)
            return response.status_code == 200
        except Exception as e:
            print(f"Connection failed: {e}")
            return False

# Initialize client
client = QuantumAPIClient()
if client.test_connection():
    print("✅ Connected to Quantum AI Agent successfully!")
else:
    print("❌ Failed to connect to Quantum AI Agent")

const axios = require('axios');
require('dotenv').config();

class QuantumAPIClient {
    constructor() {
        this.baseURL = process.env.QUANTUM_API_BASE_URL;
        this.token = process.env.QUANTUM_API_TOKEN;
        this.headers = {
            'Authorization': `Bearer ${this.token}`,
            'Content-Type': 'application/json'
        };
    }
    
    async testConnection() {
        try {
            const response = await axios.get(`${this.baseURL}/test`, {
                headers: this.headers
            });
            return response.status === 200;
        } catch (error) {
            console.error('Connection failed:', error.message);
            return false;
        }
    }
}

// Initialize client
const client = new QuantumAPIClient();
client.testConnection().then(success => {
    if (success) {
        console.log('✅ Connected to Quantum AI Agent successfully!');
    } else {
        console.log('❌ Failed to connect to Quantum AI Agent');
    }
});

import base64

def upload_test_document(client):
    # Create a simple text document
    text_content = "Hello Quantum AI Agent! This is a test document."
    base64_content = base64.b64encode(text_content.encode()).decode()
    
    data = {
        "owner_id": int(os.getenv('QUANTUM_OWNER_ID')),
        "company_id": int(os.getenv('QUANTUM_COMPANY_ID')),
        "agent_id": int(os.getenv('QUANTUM_AGENT_ID')),
        "documents": [
            {
                "name": "test-document.txt",
                "mimetype": "text/plain",
                "base64": base64_content
            }
        ]
    }
    
    response = requests.post(
        f'{client.base_url}/documents/create',
        headers=client.headers,
        json=data
    )
    
    return response.json()

# Test upload
result = upload_test_document(client)
print("Upload result:", result)

async function uploadTestDocument(client) {
    // Create a simple text document
    const textContent = "Hello Quantum AI Agent! This is a test document.";
    const base64Content = Buffer.from(textContent).toString('base64');
    
    const data = {
        owner_id: parseInt(process.env.QUANTUM_OWNER_ID),
        company_id: parseInt(process.env.QUANTUM_COMPANY_ID),
        agent_id: parseInt(process.env.QUANTUM_AGENT_ID),
        documents: [
            {
                name: "test-document.txt",
                mimetype: "text/plain",
                base64: base64Content
            }
        ]
    };
    
    try {
        const response = await axios.post(
            `${client.baseURL}/documents/create`,
            data,
            { headers: client.headers }
        );
        return response.data;
    } catch (error) {
        console.error('Upload failed:', error.response?.data || error.message);
        return null;
    }
}

// Test upload
uploadTestDocument(client).then(result => {
    console.log('Upload result:', result);
});