aitbc/docs/agent-sdk

AITBC Agent SDK Documentation

🤖 Overview

The AITBC Agent SDK provides a comprehensive toolkit for developing AI agents that interact with the AITBC blockchain network. Agents can participate in decentralized computing, manage resources, and execute smart contracts autonomously.

🚀 Quick Start

Installation

pip install aitbc-agent-sdk

Basic Agent Example

from aitbc_agent_sdk import Agent, AgentConfig
from aitbc_agent_sdk.blockchain import BlockchainClient
from aitbc_agent_sdk.ai import AIModel

# Configure agent
config = AgentConfig(
    name="my-agent",
    blockchain_network="mainnet",
    ai_model="gpt-4",
    wallet_private_key="your-private-key"
)

# Create agent
agent = Agent(config)

# Start agent
agent.start()

# Execute tasks
result = agent.execute_task("compute", {"data": [1, 2, 3, 4, 5]})
print(f"Result: {result}")

📚 Core Components

1. Agent Class

The main Agent class provides the core functionality for creating and managing AI agents.

class Agent:
    def __init__(self, config: AgentConfig)
    def start(self) -> None
    def stop(self) -> None
    def execute_task(self, task_type: str, params: Dict) -> Any
    def register_with_network(self) -> str
    def get_balance(self) -> float
    def send_transaction(self, to: str, amount: float) -> str

2. Blockchain Integration

Seamless integration with the AITBC blockchain for resource management and transactions.

from aitbc_agent_sdk.blockchain import BlockchainClient

client = BlockchainClient(network="mainnet")

# Get agent info
agent_info = client.get_agent_info(agent_address)
print(f"Agent reputation: {agent_info.reputation}")

# Submit computation task
task_id = client.submit_computation_task(
    algorithm="neural_network",
    data_hash="QmHash...",
    reward=10.0
)

# Check task status
status = client.get_task_status(task_id)

3. AI Model Integration

Built-in support for various AI models and frameworks.

from aitbc_agent_sdk.ai import AIModel, ModelConfig

# Configure AI model
model_config = ModelConfig(
    model_type="transformer",
    framework="pytorch",
    device="cuda"
)

# Load model
model = AIModel(config=model_config)

# Execute inference
result = model.predict(input_data)

🔧 Configuration

Agent Configuration

from aitbc_agent_sdk import AgentConfig

config = AgentConfig(
    # Basic settings
    name="my-agent",
    version="1.0.0",
    
    # Blockchain settings
    blockchain_network="mainnet",
    rpc_url="https://rpc.aitbc.net",
    wallet_private_key="0x...",
    
    # AI settings
    ai_model="gpt-4",
    ai_provider="openai",
    max_tokens=1000,
    
    # Resource settings
    max_cpu_cores=4,
    max_memory_gb=8,
    max_gpu_count=1,
    
    # Network settings
    peer_discovery=True,
    heartbeat_interval=30,
    
    # Security settings
    encryption_enabled=True,
    authentication_required=True
)

Environment Variables

# Blockchain configuration
AITBC_NETWORK=mainnet
AITBC_RPC_URL=https://rpc.aitbc.net
AITBC_PRIVATE_KEY=0x...

# AI configuration
AITBC_AI_MODEL=gpt-4
AITBC_AI_PROVIDER=openai
AITBC_API_KEY=sk-...

# Agent configuration
AITBC_AGENT_NAME=my-agent
AITBC_MAX_CPU=4
AITBC_MAX_MEMORY=8
AITBC_MAX_GPU=1

🎯 Use Cases

1. Computing Agent

Agents that provide computational resources to the network.

from aitbc_agent_sdk import Agent, AgentConfig
from aitbc_agent_sdk.computing import ComputingTask

class ComputingAgent(Agent):
    def __init__(self, config):
        super().__init__(config)
        self.computing_engine = ComputingEngine(config)
    
    def handle_computation_request(self, task):
        """Handle incoming computation requests"""
        result = self.computing_engine.execute(task)
        return result
    
    def register_computing_services(self):
        """Register available computing services"""
        services = [
            {"type": "neural_network", "price": 0.1},
            {"type": "data_processing", "price": 0.05},
            {"type": "encryption", "price": 0.02}
        ]
        
        for service in services:
            self.register_service(service)

# Usage
config = AgentConfig(name="computing-agent")
agent = ComputingAgent(config)
agent.start()

2. Data Processing Agent

Agents that specialize in data processing and analysis.

from aitbc_agent_sdk import Agent
from aitbc_agent_sdk.data import DataProcessor

class DataAgent(Agent):
    def __init__(self, config):
        super().__init__(config)
        self.processor = DataProcessor(config)
    
    def process_dataset(self, dataset_hash):
        """Process a dataset and return results"""
        data = self.load_dataset(dataset_hash)
        results = self.processor.analyze(data)
        return results
    
    def train_model(self, training_data):
        """Train AI model on provided data"""
        model = self.processor.train(training_data)
        return model.save()

# Usage
agent = DataAgent(config)
agent.start()

3. Oracle Agent

Agents that provide external data to the blockchain.

from aitbc_agent_sdk import Agent
from aitbc_agent_sdk.oracle import OracleProvider

class OracleAgent(Agent):
    def __init__(self, config):
        super().__init__(config)
        self.oracle = OracleProvider(config)
    
    def get_price_data(self, symbol):
        """Get real-time price data"""
        return self.oracle.get_price(symbol)
    
    def get_weather_data(self, location):
        """Get weather information"""
        return self.oracle.get_weather(location)
    
    def submit_oracle_data(self, data_type, value):
        """Submit data to blockchain oracle"""
        return self.blockchain_client.submit_oracle_data(data_type, value)

# Usage
agent = OracleAgent(config)
agent.start()

🔐 Security

Private Key Management

from aitbc_agent_sdk.security import KeyManager

# Secure key management
key_manager = KeyManager()
key_manager.load_from_encrypted_file("keys.enc", "password")

# Use in agent
config = AgentConfig(
    wallet_private_key=key_manager.get_private_key()
)

Authentication

from aitbc_agent_sdk.auth import Authenticator

auth = Authenticator(config)

# Generate authentication token
token = auth.generate_token(agent_id, expires_in=3600)

# Verify token
is_valid = auth.verify_token(token, agent_id)

Encryption

from aitbc_agent_sdk.crypto import Encryption

# Encrypt sensitive data
encryption = Encryption()
encrypted_data = encryption.encrypt(data, public_key)

# Decrypt data
decrypted_data = encryption.decrypt(encrypted_data, private_key)

📊 Monitoring and Analytics

Performance Monitoring

from aitbc_agent_sdk.monitoring import PerformanceMonitor

monitor = PerformanceMonitor(agent)

# Start monitoring
monitor.start()

# Get performance metrics
metrics = monitor.get_metrics()
print(f"CPU usage: {metrics.cpu_usage}%")
print(f"Memory usage: {metrics.memory_usage}%")
print(f"Tasks completed: {metrics.tasks_completed}")

Logging

import logging
from aitbc_agent_sdk.logging import AgentLogger

# Setup agent logging
logger = AgentLogger("my-agent")
logger.setLevel(logging.INFO)

# Log events
logger.info("Agent started successfully")
logger.warning("High memory usage detected")
logger.error("Task execution failed", exc_info=True)

🧪 Testing

Unit Tests

import unittest
from aitbc_agent_sdk import Agent, AgentConfig

class TestAgent(unittest.TestCase):
    def setUp(self):
        self.config = AgentConfig(
            name="test-agent",
            blockchain_network="testnet"
        )
        self.agent = Agent(self.config)
    
    def test_agent_initialization(self):
        self.assertIsNotNone(self.agent)
        self.assertEqual(self.agent.name, "test-agent")
    
    def test_task_execution(self):
        result = self.agent.execute_task("test", {})
        self.assertIsNotNone(result)

if __name__ == "__main__":
    unittest.main()

Integration Tests

import pytest
from aitbc_agent_sdk import Agent, AgentConfig

@pytest.mark.integration
def test_blockchain_integration():
    config = AgentConfig(blockchain_network="testnet")
    agent = Agent(config)
    
    # Test blockchain connection
    balance = agent.get_balance()
    assert isinstance(balance, float)
    
    # Test transaction
    tx_hash = agent.send_transaction(
        to="0x123...",
        amount=0.1
    )
    assert len(tx_hash) == 66  # Ethereum transaction hash length

🚀 Deployment

Docker Deployment

FROM python:3.13-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install -r requirements.txt

COPY . .

# Create non-root user
RUN useradd -m -u 1000 agent
USER agent

# Start agent
CMD ["python", "agent.py"]

Kubernetes Deployment

apiVersion: apps/v1
kind: Deployment
metadata:
  name: aitbc-agent
spec:
  replicas: 3
  selector:
    matchLabels:
      app: aitbc-agent
  template:
    metadata:
      labels:
        app: aitbc-agent
    spec:
      containers:
      - name: agent
        image: aitbc/agent:latest
        env:
        - name: AITBC_NETWORK
          value: "mainnet"
        - name: AITBC_PRIVATE_KEY
          valueFrom:
            secretKeyRef:
              name: agent-secrets
              key: private-key
        resources:
          requests:
            cpu: 100m
            memory: 128Mi
          limits:
            cpu: 500m
            memory: 512Mi

📚 API Reference

Agent Methods

Method	Description	Parameters	Returns
start()	Start the agent	None	None
stop()	Stop the agent	None	None
execute_task()	Execute a task	task_type, params	Any
get_balance()	Get wallet balance	None	float
send_transaction()	Send transaction	to, amount	str

Blockchain Client Methods

Method	Description	Parameters	Returns
get_agent_info()	Get agent information	agent_address	AgentInfo
submit_computation_task()	Submit task	algorithm, data_hash, reward	str
get_task_status()	Get task status	task_id	TaskStatus

🤝 Contributing

We welcome contributions to the AITBC Agent SDK! Please see our Contributing Guide for details.

Development Setup

# Clone repository
git clone https://github.com/oib/AITBC-agent-sdk.git
cd AITBC-agent-sdk

# Install development dependencies
pip install -e ".[dev]"

# Run tests
pytest

# Run linting
black .
isort .

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🆘 Support

• Documentation: https://docs.aitbc.net/agent-sdk
• Issues: GitHub Issues
• Discord: AITBC Community
• Email: support@aitbc.net