Chapter 11: Code Examples

# config.py
import os
from dataclasses import dataclass
 
@dataclass
class Config:
    api_key: str
    base_url: str = "https://api.polysystems.ai"
    jwt_token: str = None
    timeout: int = 30
    max_retries: int = 3
 
def load_config():
    """Load configuration from environment variables"""
    return Config(
        api_key=os.getenv('PS_API_KEY'),
        jwt_token=os.getenv('PS_JWT_TOKEN'),
        base_url=os.getenv('PS_API_URL', 'https://api.polysystems.ai')
    )
 
config = load_config()

# polysystems_client.py
import requests
import time
import logging
from typing import Optional, Dict, List, Any
from functools import wraps
 
logger = logging.getLogger(__name__)
 
class APIError(Exception):
    """Custom API error"""
    def __init__(self, status_code, error_type, message, request_id=None):
        self.status_code = status_code
        self.error_type = error_type
        self.message = message
        self.request_id = request_id
        super().__init__(f"{error_type}: {message}")
 
def retry_on_error(max_retries=3):
    """Decorator for retrying failed requests"""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(max_retries):
                try:
                    return func(*args, **kwargs)
                except APIError as e:
                    if e.status_code == 429:  # Rate limit
                        if attempt < max_retries - 1:
                            time.sleep(2 ** attempt)
                            continue
                    elif e.status_code >= 500:  # Server error
                        if attempt < max_retries - 1:
                            time.sleep(2 ** attempt)
                            continue
                    raise
            raise APIError(500, "MaxRetriesExceeded", "Maximum retry attempts exceeded")
        return wrapper
    return decorator
 
class PolysystemsClient:
    """Complete Polysystems API client"""
    
    def __init__(self, api_key: str, base_url: str = "https://api.polysystems.ai"):
        self.api_key = api_key
        self.base_url = base_url
        self.session = requests.Session()
        self.session.headers.update({
            'X-API-Key': api_key,
            'Content-Type': 'application/json'
        })
    
    def _handle_response(self, response: requests.Response) -> Dict:
        """Handle API response"""
        if 200 <= response.status_code < 300:
            return response.json()
        
        try:
            error_data = response.json()
            raise APIError(
                response.status_code,
                error_data.get('error', 'Unknown'),
                error_data.get('message', 'No message'),
                error_data.get('request_id')
            )
        except ValueError:
            raise APIError(response.status_code, 'HTTPError', response.text)
    
    @retry_on_error(max_retries=3)
    def _request(self, method: str, endpoint: str, **kwargs) -> Dict:
        """Make HTTP request"""
        url = f"{self.base_url}{endpoint}"
        response = self.session.request(method, url, **kwargs)
        return self._handle_response(response)
    
    # Chat Completion
    def chat_completion(self, messages: List[Dict], model: str = "gpt-4", **kwargs) -> Dict:
        """Chat completion endpoint"""
        return self._request('POST', '/api/hub/agents/chat', json={
            'messages': messages,
            'model': model,
            **kwargs
        })
    
    # Memory Management
    def store_memory(self, key: str, value: str, metadata: Optional[Dict] = None) -> Dict:
        """Store memory entry"""
        return self._request('POST', '/api/hub/memory', json={
            'key': key,
            'value': value,
            'metadata': metadata or {}
        })
    
    def retrieve_memory(self, memory_id: str) -> Dict:
        """Retrieve memory by ID"""
        return self._request('GET', f'/api/hub/memory/{memory_id}')
    
    def search_memory(self, query: str, limit: int = 10) -> Dict:
        """Search memories"""
        return self._request('POST', '/api/hub/memory/search', json={
            'query': query,
            'limit': limit
        })
    
    # Task Management
    def submit_task(self, task_type: str, parameters: Dict, priority: str = "normal") -> Dict:
        """Submit a task"""
        return self._request('POST', '/api/hub/tasks', json={
            'task_type': task_type,
            'parameters': parameters,
            'priority': priority
        })
    
    def get_task_status(self, task_id: str) -> Dict:
        """Get task status"""
        return self._request('GET', f'/api/hub/tasks/{task_id}')
    
    # RAG Operations
    def index_document(self, content: str, metadata: Optional[Dict] = None) -> Dict:
        """Index document for RAG"""
        return self._request('POST', '/api/hub/rag/index', json={
            'content': content,
            'metadata': metadata or {}
        })
    
    def rag_generate(self, query: str, top_k: int = 5) -> Dict:
        """Generate with RAG"""
        return self._request('POST', '/api/hub/rag/generate', json={
            'query': query,
            'top_k': top_k
        })
    
    # Balance & Payments
    def get_balance(self, jwt_token: str) -> Dict:
        """Get account balance"""
        headers = {'Authorization': f'Bearer {jwt_token}'}
        return self._request('GET', '/api/payments/credits/balance', headers=headers)
    
    def create_payment(self, jwt_token: str, amount_usd: float, currency: str = "ETH") -> Dict:
        """Create payment"""
        headers = {'Authorization': f'Bearer {jwt_token}'}
        return self._request('POST', '/api/payments/payments', headers=headers, json={
            'amount_usd': amount_usd,
            'currency': currency
        })
    
    # Access Keys
    def list_access_keys(self, jwt_token: str) -> List[Dict]:
        """List access keys"""
        headers = {'Authorization': f'Bearer {jwt_token}'}
        return self._request('GET', '/api/keys', headers=headers)
    
    def create_access_key(self, jwt_token: str, name: str, expires_at: Optional[str] = None) -> Dict:
        """Create access key"""
        headers = {'Authorization': f'Bearer {jwt_token}'}
        return self._request('POST', '/api/keys', headers=headers, json={
            'name': name,
            'expires_at': expires_at
        })
    
    def set_spending_limits(self, jwt_token: str, key_id: str, 
                           daily_limit: Optional[float] = None,
                           monthly_limit: Optional[float] = None,
                           per_request_limit: Optional[float] = None) -> Dict:
        """Set spending limits"""
        headers = {'Authorization': f'Bearer {jwt_token}'}
        return self._request('PUT', f'/api/keys/{key_id}/limits', headers=headers, json={
            'daily_limit': daily_limit,
            'monthly_limit': monthly_limit,
            'per_request_limit': per_request_limit
        })
 
# Usage Example
if __name__ == '__main__':
    # Initialize client
    client = PolysystemsClient(api_key='ps_live_your_key_here')
    
    # Chat completion
    response = client.chat_completion(
        messages=[
            {'role': 'user', 'content': 'What is machine learning?'}
        ],
        temperature=0.7,
        max_tokens=200
    )
    print(response)
    
    # Store and search memory
    client.store_memory('user_pref', 'dark_mode', metadata={'user_id': '123'})
    results = client.search_memory('dark mode')
    print(results)

# app.py
from flask import Flask, request, jsonify
from polysystems_client import PolysystemsClient, APIError
import os
 
app = Flask(__name__)
client = PolysystemsClient(api_key=os.getenv('PS_API_KEY'))
 
@app.route('/api/chat', methods=['POST'])
def chat():
    """Chat endpoint"""
    try:
        data = request.get_json()
        messages = data.get('messages', [])
        
        if not messages:
            return jsonify({'error': 'messages required'}), 400
        
        response = client.chat_completion(messages)
        return jsonify(response)
        
    except APIError as e:
        return jsonify({
            'error': e.error_type,
            'message': e.message
        }), e.status_code
    except Exception as e:
        return jsonify({'error': str(e)}), 500
 
@app.route('/api/search', methods=['POST'])
def search():
    """Memory search endpoint"""
    try:
        data = request.get_json()
        query = data.get('query')
        
        if not query:
            return jsonify({'error': 'query required'}), 400
        
        results = client.search_memory(query)
        return jsonify(results)
        
    except APIError as e:
        return jsonify({
            'error': e.error_type,
            'message': e.message
        }), e.status_code
 
if __name__ == '__main__':
    app.run(debug=True)

# async_client.py
import aiohttp
import asyncio
from typing import Dict, List
 
class AsyncPolysystemsClient:
    """Async API client"""
    
    def __init__(self, api_key: str, base_url: str = "https://api.polysystems.ai"):
        self.api_key = api_key
        self.base_url = base_url
        self.headers = {
            'X-API-Key': api_key,
            'Content-Type': 'application/json'
        }
    
    async def chat_completion(self, messages: List[Dict], **kwargs) -> Dict:
        """Async chat completion"""
        async with aiohttp.ClientSession(headers=self.headers) as session:
            async with session.post(
                f'{self.base_url}/api/hub/agents/chat',
                json={'messages': messages, **kwargs}
            ) as response:
                return await response.json()
    
    async def batch_chat_completions(self, requests: List[Dict]) -> List[Dict]:
        """Process multiple chat requests concurrently"""
        tasks = [
            self.chat_completion(req['messages'], **req.get('options', {}))
            for req in requests
        ]
        return await asyncio.gather(*tasks)
 
# Usage
async def main():
    client = AsyncPolysystemsClient(api_key='ps_live_your_key_here')
    
    # Single request
    response = await client.chat_completion([
        {'role': 'user', 'content': 'Hello!'}
    ])
    print(response)
    
    # Batch requests
    requests = [
        {'messages': [{'role': 'user', 'content': f'Question {i}'}]}
        for i in range(10)
    ]
    responses = await client.batch_chat_completions(requests)
    print(f"Processed {len(responses)} requests")
 
if __name__ == '__main__':
    asyncio.run(main())

// polysystems-client.js
const axios = require('axios');
 
class APIError extends Error {
  constructor(statusCode, errorType, message, requestId) {
    super(`${errorType}: ${message}`);
    this.statusCode = statusCode;
    this.errorType = errorType;
    this.requestId = requestId;
    this.name = 'APIError';
  }
}
 
class PolysystemsClient {
  constructor(apiKey, baseURL = 'https://api.polysystems.ai') {
    this.apiKey = apiKey;
    this.baseURL = baseURL;
    this.client = axios.create({
      baseURL: baseURL,
      headers: {
        'X-API-Key': apiKey,
        'Content-Type': 'application/json'
      },
      timeout: 30000
    });
  }
 
  async _request(method, endpoint, data = null, maxRetries = 3) {
    for (let attempt = 0; attempt < maxRetries; attempt++) {
      try {
        const response = await this.client.request({
          method,
          url: endpoint,
          data
        });
        return response.data;
      } catch (error) {
        if (error.response) {
          const { status, data } = error.response;
          
          // Retry on rate limit
          if (status === 429 && attempt < maxRetries - 1) {
            const retryAfter = parseInt(error.response.headers['retry-after'] || 60);
            await this.sleep(retryAfter * 1000);
            continue;
          }
          
          // Retry on server error
          if (status >= 500 && attempt < maxRetries - 1) {
            await this.sleep(Math.pow(2, attempt) * 1000);
            continue;
          }
          
          throw new APIError(
            status,
            data.error || 'Unknown',
            data.message || 'No message',
            data.request_id
          );
        }
        
        if (attempt < maxRetries - 1) {
          await this.sleep(Math.pow(2, attempt) * 1000);
          continue;
        }
        throw error;
      }
    }
    throw new Error('Max retries exceeded');
  }
 
  sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
 
  // Chat Completion
  async chatCompletion(messages, options = {}) {
    return this._request('POST', '/api/hub/agents/chat', {
      messages,
      ...options
    });
  }
 
  // Memory
  async storeMemory(key, value, metadata = {}) {
    return this._request('POST', '/api/hub/memory', {
      key,
      value,
      metadata
    });
  }
 
  async searchMemory(query, limit = 10) {
    return this._request('POST', '/api/hub/memory/search', {
      query,
      limit
    });
  }
 
  // Tasks
  async submitTask(taskType, parameters, priority = 'normal') {
    return this._request('POST', '/api/hub/tasks', {
      task_type: taskType,
      parameters,
      priority
    });
  }
 
  async getTaskStatus(taskId) {
    return this._request('GET', `/api/hub/tasks/${taskId}`);
  }
 
  // RAG
  async indexDocument(content, metadata = {}) {
    return this._request('POST', '/api/hub/rag/index', {
      content,
      metadata
    });
  }
 
  async ragGenerate(query, topK = 5) {
    return this._request('POST', '/api/hub/rag/generate', {
      query,
      top_k: topK
    });
  }
}
 
module.exports = { PolysystemsClient, APIError };

// server.js
const express = require('express');
const { PolysystemsClient, APIError } = require('./polysystems-client');
 
const app = express();
app.use(express.json());
 
const client = new PolysystemsClient(process.env.PS_API_KEY);
 
app.post('/api/chat', async (req, res) => {
  try {
    const { messages } = req.body;
    
    if (!messages || !Array.isArray(messages)) {
      return res.status(400).json({ error: 'messages array required' });
    }
    
    const response = await client.chatCompletion(messages);
    res.json(response);
    
  } catch (error) {
    if (error instanceof APIError) {
      res.status(error.statusCode).json({
        error: error.errorType,
        message: error.message
      });
    } else {
      res.status(500).json({ error: error.message });
    }
  }
});
 
app.post('/api/search', async (req, res) => {
  try {
    const { query } = req.body;
    
    if (!query) {
      return res.status(400).json({ error: 'query required' });
    }
    
    const results = await client.searchMemory(query);
    res.json(results);
    
  } catch (error) {
    if (error instanceof APIError) {
      res.status(error.statusCode).json({
        error: error.errorType,
        message: error.message
      });
    } else {
      res.status(500).json({ error: error.message });
    }
  }
});
 
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});

// usePolysystems.js - React Hook
import { useState, useCallback } from 'react';
 
export const usePolysystems = (apiKey) => {
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState(null);
 
  const chatCompletion = useCallback(async (messages, options = {}) => {
    setLoading(true);
    setError(null);
    
    try {
      const response = await fetch('https://api.polysystems.ai/api/hub/agents/chat', {
        method: 'POST',
        headers: {
          'X-API-Key': apiKey,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          messages,
          ...options
        })
      });
      
      if (!response.ok) {
        const errorData = await response.json();
        throw new Error(errorData.message || 'API request failed');
      }
      
      const data = await response.json();
      return data;
      
    } catch (err) {
      setError(err.message);
      throw err;
    } finally {
      setLoading(false);
    }
  }, [apiKey]);
 
  return { chatCompletion, loading, error };
};
 
// ChatComponent.jsx
import React, { useState } from 'react';
import { usePolysystems } from './usePolysystems';
 
function ChatComponent() {
  const [messages, setMessages] = useState([]);
  const [input, setInput] = useState('');
  const { chatCompletion, loading, error } = usePolysystems(
    process.env.REACT_APP_PS_API_KEY
  );
 
  const handleSend = async () => {
    if (!input.trim()) return;
 
    const userMessage = { role: 'user', content: input };
    const newMessages = [...messages, userMessage];
    setMessages(newMessages);
    setInput('');
 
    try {
      const response = await chatCompletion(newMessages);
      setMessages([...newMessages, {
        role: 'assistant',
        content: response.message
      }]);
    } catch (err) {
      console.error('Chat error:', err);
    }
  };
 
  return (
    <div className="chat-container">
      <div className="messages">
        {messages.map((msg, i) => (
          <div key={i} className={`message ${msg.role}`}>
            {msg.content}
          </div>
        ))}
      </div>
      
      {error && <div className="error">{error}</div>}
      
      <div className="input-area">
        <input
          value={input}
          onChange={(e) => setInput(e.target.value)}
          onKeyPress={(e) => e.key === 'Enter' && handleSend()}
          disabled={loading}
          placeholder="Type a message..."
        />
        <button onClick={handleSend} disabled={loading}>
          {loading ? 'Sending...' : 'Send'}
        </button>
      </div>
    </div>
  );
}
 
export default ChatComponent;

// polysystems_client.go
package polysystems
 
import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
    "time"
)
 
type APIError struct {
    StatusCode int
    ErrorType  string
    Message    string
    RequestID  string
}
 
func (e *APIError) Error() string {
    return fmt.Sprintf("%s: %s", e.ErrorType, e.Message)
}
 
type Client struct {
    APIKey     string
    BaseURL    string
    HTTPClient *http.Client
}
 
func NewClient(apiKey string) *Client {
    return &Client{
        APIKey:  apiKey,
        BaseURL: "https://api.polysystems.ai",
        HTTPClient: &http.Client{
            Timeout: 30 * time.Second,
        },
    }
}
 
func (c *Client) request(method, endpoint string, body interface{}) (map[string]interface{}, error) {
    var reqBody []byte
    var err error
    
    if body != nil {
        reqBody, err = json.Marshal(body)
        if err != nil {
            return nil, err
        }
    }
    
    url := c.BaseURL + endpoint
    req, err := http.NewRequest(method, url, bytes.NewBuffer(reqBody))
    if err != nil {
        return nil, err
    }
    
    req.Header.Set("X-API-Key", c.APIKey)
    req.Header.Set("Content-Type", "application/json")
    
    resp, err := c.HTTPClient.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    
    respBody, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }
    
    var result map[string]interface{}
    if err := json.Unmarshal(respBody, &result); err != nil {
        return nil, err
    }
    
    if resp.StatusCode >= 400 {
        return nil, &APIError{
            StatusCode: resp.StatusCode,
            ErrorType:  result["error"].(string),
            Message:    result["message"].(string),
        }
    }
    
    return result, nil
}
 
func (c *Client) ChatCompletion(messages []map[string]string, options map[string]interface{}) (map[string]interface{}, error) {
    body := map[string]interface{}{
        "messages": messages,
    }
    for k, v := range options {
        body[k] = v
    }
    
    return c.request("POST", "/api/hub/agents/chat", body)
}
 
func (c *Client) StoreMemory(key, value string, metadata map[string]interface{}) (map[string]interface{}, error) {
    body := map[string]interface{}{
        "key":      key,
        "value":    value,
        "metadata": metadata,
    }
    
    return c.request("POST", "/api/hub/memory", body)
}
 
func (c *Client) SearchMemory(query string, limit int) (map[string]interface{}, error) {
    body := map[string]interface{}{
        "query": query,
        "limit": limit,
    }
    
    return c.request("POST", "/api/hub/memory/search", body)
}

// main.go
package main
 
import (
    "fmt"
    "log"
    "os"
    "polysystems"
)
 
func main() {
    client := polysystems.NewClient(os.Getenv("PS_API_KEY"))
    
    // Chat completion
    messages := []map[string]string{
        {"role": "user", "content": "What is Go?"},
    }
    
    response, err := client.ChatCompletion(messages, map[string]interface{}{
        "temperature": 0.7,
        "max_tokens":  200,
    })
    
    if err != nil {
        log.Fatalf("Error: %v", err)
    }
    
    fmt.Printf("Response: %v\n", response)
    
    // Store memory
    metadata := map[string]interface{}{
        "user_id": "123",
    }
    
    _, err = client.StoreMemory("user_lang", "go", metadata)
    if err != nil {
        log.Fatalf("Error storing memory: %v", err)
    }
    
    fmt.Println("Memory stored successfully")
}

#!/usr/bin/env python3
# ps-cli.py
import click
import os
from polysystems_client import PolysystemsClient, APIError
from rich.console import Console
from rich.table import Table
 
console = Console()
client = PolysystemsClient(api_key=os.getenv('PS_API_KEY'))
 
@click.group()
def cli():
    """Polysystems CLI Tool"""
    pass
 
@cli.command()
@click.argument('message')
@click.option('--model', default='gpt-4', help='Model to use')
def chat(message, model):
    """Send a chat message"""
    try:
        response = client.chat_completion(
            messages=[{'role': 'user', 'content': message}],
            model=model
        )
        console.print(f"[green]Response:[/green] {response['message']}")
    except APIError as e:
        console.print(f"[red]Error:[/red] {e.message}")
 
@cli.command()
@click.argument('query')
def search(query):
    """Search memories"""
    try:
        results = client.search_memory(query)
        
        table = Table(title="Search Results")
        table.add_column("Key", style="cyan")
        table.add_column("Value", style="green")
        
        for item in results.get('results', []):
            table.add_row(item['key'], item['value'][:50])
        
        console.print(table)
    except APIError as e:
        console.print(f"[red]Error:[/red] {e.message}")
 
@cli.command()
def balance():
    """Check account balance"""
    try:
        jwt_token = os.getenv('PS_JWT_TOKEN')
        result = client.get_balance(jwt_token)
        console.print(f"[green]Balance:[/green] ${result['balance']:.4f}")
    except APIError as e:
        console.print(f"[red]Error:[/red] {e.message}")
 
if __name__ == '__main__':
    cli()

// streaming-chat.js
const WebSocket = require('ws');
 
class StreamingChatClient {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.ws = null;
  }
 
  connect() {
    return new Promise((resolve, reject) => {
      this.ws = new WebSocket(
        `wss://api.polysystems.ai/api/ws/stream?token=${this.apiKey}`
      );
 
      this.ws.on('open', () => {
        console.log('Connected to streaming API');
        resolve();
      });
 
      this.ws.on('error', (error) => {
        console.error('WebSocket error:', error);
        reject(error);
      });
    });
  }
 
  streamChat(messages, onChunk, onComplete) {
    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
      throw new Error('WebSocket not connected');
    }
 
    let fullResponse = '';
 
    this.ws.on('message', (data) => {
      const chunk = JSON.parse(data);
 
      if (chunk.type === 'chunk') {
        fullResponse += chunk.content;
        onChunk(chunk.content);
      } else if (chunk.type === 'complete') {
        onComplete(fullResponse);
      }
    });
 
    this.ws.send(JSON.stringify({
      action: 'chat',
      messages: messages
    }));
  }
 
  disconnect() {
    if (this.ws) {
      this.ws.close();
    }
  }
}
 
// Usage
(async () => {
  const client = new StreamingChatClient(process.env.PS_API_KEY);
  
  await client.connect();
  
  client.streamChat(
    [{ role: 'user', content: 'Tell me a story' }],
    (chunk) => process.stdout.write(chunk),
    (full) => {
      console.log('\n\nComplete response received');
      client.disconnect();
    }
  );
})();