Skip to main content

​
Artos API Documentation

Welcome to the Artos API documentation. Artos provides a comprehensive platform for building, customizing, and optimizing AI workflows through five core API areas that work together to deliver powerful, scalable solutions.

​
Overview

Artos is designed around the principle of structured agent composition rather than prompt-based guessing. The platform provides transparent, accurate, and extensible AI capabilities through a well-defined API structure that enables both simple integrations and complex customizations.

​
Key Benefits

  • Higher Accuracy: Structured agent selection vs. prompt-based approaches
  • Transparent Composition: Clear visibility into which agents are used and why
  • Scalable Architecture: Easy extension with custom agents and workflows
  • Context-Aware Processing: Intelligent selection based on data types and usage patterns
  • Performance Optimization: Automatic selection of optimal agents for specific tasks
  • Complete Customization: From frontend components to backend processing pipelines

​
Core API Areas

​
1. Connectors API

Extend Artos functionality with custom Connectors for agent discovery and data-agent mapping Connectors are the primary mechanism for extending Artos functionality. They define the relationship between data types, processing requirements, and the appropriate agents to handle specific tasks. Key Features:
  • Agent discovery and intelligent selection
  • Data-agent mapping based on content types
  • AWS Bedrock and Azure Foundry integration
  • Custom agent definition and deployment
  • Performance optimization and cost control
When to Use:
  • Adding new processing capabilities
  • Integrating with external AI services
  • Defining custom agent workflows
  • Optimizing agent selection for specific data types
from artos import ConnectorBuilder

# Create a custom connector
connector = ConnectorBuilder.create("data_processor_connector") \
    .add_agent_types(["data_validator", "table_processor"]) \
    .add_data_types(["csv", "excel", "json"]) \
    .set_usage_rules({
        "when": "data contains tabular information",
        "priority": "high"
    }) \
    .build()

​
2. Post-Processing API

Configure and manage post-processing pipelines for content refinement, style matching, and quality control The Post-Processing API manages the sequence of agents that refine content after execution, enabling lean content generation while maintaining high quality and consistency. Key Features:
  • Content optimization and refinement
  • Style matching and brand consistency
  • Quality control and hallucination detection
  • Custom processing steps
  • Pipeline configuration and management
When to Use:
  • Ensuring consistent output quality
  • Applying brand guidelines and style rules
  • Implementing quality control measures
  • Adding custom refinement steps
from artos import ProcessingStep

# Add custom processing step
step = ProcessingStep(
    name="Content Optimizer",
    agent_type="content_optimizer",
    configuration={
        "targetLength": "concise",
        "styleGuide": "professional",
        "removeRedundancy": True
    }
)

​
3. Frontend Customization

Embed the Artos platform directly into your applications with complete customization control The Frontend Customization API provides a single, embeddable Artos component that can be integrated into any React application with complete control over authentication, styling, and user experience. Key Features:
  • Single embeddable ArtosApp component
  • Custom authentication integration
  • Complete styling and theming control
  • Responsive design and mobile support
  • TypeScript support with full type safety
When to Use:
  • Embedding Artos in existing applications
  • Custom branding and styling
  • Role-based access control
  • Multi-tenant deployments
import { ArtosApp } from '@artos/react-component';

<ArtosApp
  apiKey="your_api_key"
  userId={user.id}
  userRole={user.role}
  theme="light"
  className="custom-artos-app"
/>

​
4. Platform Integration

Integrate Artos workflows into your existing systems with APIs, SDKs, webhooks, and database connectors Platform Integration provides comprehensive patterns for integrating Artos into your existing infrastructure, from simple API calls to complex event-driven architectures. Key Features:
  • Direct API integration patterns
  • SDK-based workflow management
  • Event-driven and webhook integration
  • Database and message queue integration
  • Custom agent creation as scripts with preset input/output fields
When to Use:
  • Integrating with existing systems
  • Building automated workflows
  • Creating custom agents and processes
  • Implementing event-driven architectures
# Create custom agent as script with preset fields
agent_definition = {
    "name": "Sales Data Processor",
    "input_fields": {
        "sales_data": {"type": "array", "required": True},
        "analysis_type": {"type": "string", "enum": ["summary", "trends", "forecasting"]}
    },
    "output_fields": {
        "insights": {"type": "object"},
        "processed_records": {"type": "number"}
    },
    "processing_script": "def process_sales_data(sales_data, analysis_type)..."
}

​
5. Debugging and Analytics API

Debug workflows, monitor performance, and optimize your Artos implementations with comprehensive analytics The Debugging and Analytics API provides comprehensive tools for monitoring, debugging, and optimizing your Artos implementations with discrete component testing and granular analytics. Key Features:
  • Discrete component testing
  • Interactive debugging with breakpoints
  • Performance monitoring and optimization
  • Custom metrics and analytics
  • Real-time monitoring and alerting
When to Use:
  • Testing individual components
  • Debugging workflow issues
  • Monitoring performance and usage
  • Optimizing system performance
  • Creating custom analytics dashboards
from artos import ComponentTester, TestCase

# Test component in isolation
test_case = TestCase(
    name="Data Validator Test",
    component_type="connector",
    component_id="data_validator",
    input_data={"test_data": "sample"},
    expected_output={"valid": True}
)

​
Getting Started

​
Authentication

All Artos API endpoints require authentication using an API key: 
curl -X GET https://api.artosai.com/connectors \
  -H "Authorization: Bearer YOUR_API_KEY"

​
Python SDK

The recommended way to interact with Artos is through our Python SDK: 
from artos import ArtosClient

# Initialize client
client = ArtosClient(api_key="your_api_key")

# List available connectors
connectors = client.connectors.list()

# Create and execute workflow
workflow = client.workflows.create({
    "name": "Data Processing Pipeline",
    "connectors": ["table_processor_connector"],
    "post_processing": ["content_optimizer", "quality_checker"]
})

​
Rate Limits

API endpoints have the following rate limits:
Endpoint TypeRate LimitWindow
Connectors100 requests1 minute
Post-Processing100 requests1 minute
Analytics200 requests1 minute
Debugging50 requests1 minute

​
Error Handling

All API endpoints return standard HTTP status codes with detailed error messages: 
{
  "error": {
    "type": "CONNECTOR_NOT_FOUND",
    "message": "Connector with ID 'invalid_id' does not exist",
    "code": 404,
    "details": {
      "connector_id": "invalid_id",
      "suggestion": "Check available connectors using the list endpoint"
    }
  }
}

​
Integration Patterns

​
Workflow Creation Process

Understanding how to create custom workflows by adding new agents:
  1. Define Custom Agents: Create agents as scripts with preset input and output fields
  2. Configure Connectors: Set up connectors to map data types to appropriate agents
  3. Design Post-Processing: Configure content refinement and quality control
  4. Test Components: Use debugging tools to test individual components
  5. Monitor Performance: Track metrics and optimize based on analytics

​
Custom Agent Development

Custom agents are essentially scripts with preset input and output field definitions: 
# Define custom agent structure
custom_agent = {
    "name": "Document Summarizer",
    "description": "Summarizes long documents into key points",
    "input_fields": {
        "document_content": {
            "type": "string", 
            "required": True,
            "description": "Full document text to summarize"
        },
        "summary_length": {
            "type": "string",
            "enum": ["brief", "detailed", "comprehensive"],
            "default": "brief"
        },
        "focus_areas": {
            "type": "array",
            "items": {"type": "string"},
            "required": False
        }
    },
    "output_fields": {
        "summary": {
            "type": "string",
            "description": "Generated summary text"
        },
        "key_points": {
            "type": "array", 
            "items": {"type": "string"}
        },
        "confidence_score": {
            "type": "number",
            "minimum": 0,
            "maximum": 1
        }
    },
    "processing_script": """
def process_document(document_content, summary_length="brief", focus_areas=None):
    # Custom processing logic here
    summary = generate_summary(document_content, summary_length)
    key_points = extract_key_points(document_content, focus_areas)
    confidence = calculate_confidence(summary, document_content)
    
    return {
        "summary": summary,
        "key_points": key_points,  
        "confidence_score": confidence
    }
    """
}

# Deploy custom agent
deployed_agent = client.agents.create(custom_agent)

​
Best Practices

​
1. Start Simple

  • Begin with basic connectors and post-processing steps
  • Test individual components before building complex workflows
  • Use the debugging tools to understand component behavior

​
2. Design for Scale

  • Use connectors to handle data type variations automatically
  • Implement proper error handling and fallback mechanisms
  • Monitor performance and optimize based on analytics

​
3. Customize Incrementally

  • Start with default components and customize gradually
  • Test customizations in staging before production deployment
  • Document all customizations for team collaboration

​
4. Monitor and Optimize

  • Set up comprehensive monitoring and alerting
  • Use A/B testing to validate improvements
  • Regularly review analytics to identify optimization opportunities

​
Support and Resources

  • API Reference: Detailed documentation for each API endpoint
  • Python SDK: Comprehensive SDK documentation with examples
  • Examples Repository: Sample implementations and use cases
  • Community Forum: Community support and discussions
  • Enterprise Support: Dedicated support for enterprise customers
Ready to get started? Choose one of the five core API areas above to begin building with Artos.