Building with Triton

​

Overview

​

Building Actions

​

Basic Action creation

• Action.py with:
  • Function signature
  • Type hints
  • Error handling
  • Documentation
• Input/output schema
• requirements.txt with dependencies

import requests
from typing import Dict, Any
import logging

logger = logging.getLogger(__name__)

def fetch_data(url: str, headers: Dict[str, str] = None) -> Dict[str, Any]:
    """
    Fetches data from a REST API endpoint.
    
    Args:
        url: The API endpoint URL
        headers: Optional HTTP headers
        
    Returns:
        JSON response as dictionary
        
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        response = requests.get(url, headers=headers, timeout=10)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.Timeout:
        logger.error(f"Timeout fetching {url}")
        raise
    except requests.exceptions.RequestException as e:
        logger.error(f"Error fetching {url}: {e}")
        raise

​

Action with specific requirements

• Generates regex pattern
• Adds Global Variable reference
• Includes validation logic
• Tests it

​

Action with API integration

• Uses the Knowledge Store to research API documentation and best practices
• Generates proper API authentication code
• Creates comprehensive testing flows
• Handles errors and edge cases
• Caches API research for future reference

• Research external APIs intelligently
• Store and retrieve API integration patterns
• Generate better code with real-world API understanding
• Test API integrations comprehensively

​

Action with OAuth integration

1. Generates the action code with OAuth token access
2. Uses get_oauth_token('google') for authentication
3. Implements Gmail API calls with proper error handling
4. Prompts you to configure OAuth modifier for Google

from triform import get_oauth_token
import requests

def send_gmail(to: str, subject: str, body: str) -> dict:
    """Send email via Gmail API using OAuth"""
    token = get_oauth_token('google')
    
    # Gmail API implementation
    response = requests.post(
        'https://gmail.googleapis.com/gmail/v1/users/me/messages/send',
        headers={'Authorization': f'Bearer {token.access_token}'},
        json={...}
    )
    return response.json()

• Knows which OAuth providers are available (Google, Slack, GitHub, etc.)
• Generates proper token access patterns
• Handles token refresh transparently
• Includes error handling for OAuth failures
• Prompts you to configure the OAuth modifier before execution

​

Data transformation Action

from typing import List, Dict

def extract_emails(users: List[Dict]) -> List[str]:
    """
    Extracts email addresses from a list of user objects.
    
    Args:
        users: List of user dictionaries with 'email' key
        
    Returns:
        List of email addresses
    """
    emails = []
    for user in users:
        if 'email' in user and user['email']:
            emails.append(user['email'])
    return emails

​

Action with loops

• Action with for loop to iterate over orders
• While loop for retry logic with exponential backoff
• Proper loop state management
• Error handling for individual items

​

Building Agents

​

Simple Agent

• System prompt:
  Copy

  You are a summarization expert. Given text input, create a concise
  summary that captures the key points. Keep summaries under 200 words.
  Use clear, professional language.
  

• Input schema: { "text": "string" }
• Output schema: { "summary": "string" }
• Model: GPT-4 (default)

​

Agent with tools

1. First checks if search_catalog Action exists
2. If not, asks: “Should I create the search_catalog Action first?”
3. Creates the Action
4. Creates the Agent with:
   • System prompt mentioning available tools
   • Tools configuration including search_catalog
   • Examples of tool usage

You are a product expert helping customers find information about our catalog.

Available tools:
- search_catalog: Search products by keyword, category, or ID

When a customer asks about products:
1. Use search_catalog to find relevant products
2. Present the information clearly
3. Suggest related products if appropriate

Always be helpful and accurate. If you can't find something, say so clearly.

​

Decision-making Agent

• Detailed system prompt with triage criteria
• Input schema: { "ticket": { "subject": "string", "body": "string", "user_tier": "string" } }
• Output schema: { "priority": "enum", "reason": "string", "suggested_assignment": "string" }
• Lower temperature (0.3) for consistent decisions

​

Building Flows

​

Linear Flow

Input → validate_input → process_data → format_output → Output

​

Parallel processing Flow

Input → fetch_source_1 ↘
      → fetch_source_2 → combine_results → Output
      → fetch_source_3 ↗

• Parallel execution of fetch Actions
• Combine node that waits for all inputs
• Proper error handling if any source fails

​

Building complete Projects

​

End-to-end example

• validate_feedback — Check feedback format
• store_feedback — Save to database
• generate_report — Format results

• analyze_feedback — Sentiment analysis and theme extraction

Input (feedback list)
  → validate_feedback (for each item)
  → store_feedback (batch)
  → analyze_feedback (Agent)
  → generate_report
  → Output (formatted report)

• Exposes the main Flow as the Project entry point
• Configured with input/output schemas
• Ready to deploy

​

Incremental building

​

Building with context

​

Building on existing components

• Scans your Project
• Finds both Actions
• Creates Flow with proper connections
• Uses correct input/output schemas

​

Consistent naming and patterns

• Reviews fetch_user_data implementation
• Creates fetch_product_data with similar structure
• Maintains consistent error handling
• Uses same coding style

​

Building variants

• Copies existing Agent
• Modifies system prompt for brevity
• Names it {original_name}_concise
• Keeps same tools and config

​

Building best practices

Start with the core path — Build the main workflow first, add enhancements later

Test as you go — Use Execute panel to verify each component

Be specific about behavior — Tell Triton exactly what you want, including edge cases

Let Triton suggest — If unsure, ask “How should I structure this?”

Review generated code — Always check what Triton built before deploying

​

Common building patterns

​

Pattern: Extract-Transform-Load (ETL)

• Extract Action (API/database/file)
• Transform Agent/Action (cleanse, normalize)
• Load Action (destination)
• Flow connecting them with error handling

​

Pattern: Request-Process-Notify

• Validation Action
• Processing Agent/Flow
• Notification Action (email/webhook)
• Status tracking

​

Pattern: Fan-out/Fan-in

• Splitter (fan-out)
• Processing Action (parallel)
• Aggregator (fan-in)
• Flow with proper concurrency

​

Pattern: Retry with backoff

• Retry decorator
• Exponential backoff
• Max attempts configuration
• Logging

​

Troubleshooting building

​

Problem: Triton doesn’t understand the request

• ❌ “Build the whole system”
• ✅ “First, create an Action that validates input”

​

Problem: Generated code doesn’t match needs

• “Create an Action like this: [paste example]”
• “The output should look like: [paste JSON]“

​

Problem: Components aren’t connecting properly

• “Connect the output of fetch_data to the input of process_data”
• “Map the ‘results’ field to ‘data’ in the next node”

​

Problem: Missing error handling

• “Add try-catch to handle network failures”
• “What if the input is empty?”

​

Next steps

1. Test each component with Execute panel
2. Edit and refine as needed
3. Debug any issues
4. Deploy your Project