Circuitry Logo
Circuitry
Open Editor

Tutorials

Learn how to build powerful automations with step-by-step tutorials.

Getting Started Tutorials

Your First AI Workflow

Build a simple workflow that uses AI to process text:

  1. Create a Start Node

    • Add input data: { "text": "Hello World" }

  2. Add an Agent Node

    • Model: GPT-5
    • Prompt: "Translate this to Spanish: {{input.text}}"
    • Temperature: 0.3

  3. Connect and Execute

    • Draw connection from Start to Agent
    • Click the Run button (▶️) in the top toolbar
    • View the translation result

Data Processing Pipeline

Transform and enrich data through multiple steps:

  1. Start with Raw Data

    {
  "users": [
    { "name": "Alice", "age": 30 },
    { "name": "Bob", "age": 25 }
  ]
}

  2. Loop Through Users

    • Add Loop Node (For Each)
    • Array Path: users

  3. Enrich Each User

    • Inside loop: Add Agent Node
    • Prompt: "Generate a bio for {{item.name}} who is {{item.age}} years old"

  4. Collect Results

    • Connect loop output to final Action node
    • Transform to desired format

API Integration Tutorials

REST API Automation

Connect to external APIs and process responses:

1. Fetch Data from API

Start → Action (HTTP Request) → Process Data

Action Configuration:

{
  "method": "GET",
  "url": "https://api.example.com/data",
  "headers": {
    "Authorization": "Bearer {{env.API_TOKEN}}"
  }
}

2. Process API Response

Add Agent node to analyze data:

Prompt:

Analyze this API response and extract key insights:
{{previousNode.output}}

Format as bullet points.

3. Send Results

Use Action node to send processed data:

{
  "method": "POST",
  "url": "https://webhook.site/unique-id",
  "body": {
    "insights": "{{previousNode.output}}",
    "timestamp": "{{now}}"
  }
}

Webhook Integration

Receive and process webhook events:

  1. Create Trigger Node

    • Type: Webhook
    • Generate unique URL

  2. Validate Webhook Data

    • Add Condition Node
    • Check: input.event === "user.created"

  3. Process Valid Events

    • True branch: Process new user
    • False branch: Log and skip

  4. Send Confirmation

    • Action node with HTTP response

Email Automation

Automated Email Responses

Build an intelligent email responder:

Workflow Structure

Email Trigger → Analyze Content → Generate Response → Send Reply

1. Set Up Email Trigger

{
  "trigger": "email",
  "filter": {
    "to": "support@example.com",
    "subject": "contains('help')"
  }
}

2. Analyze with AI

Agent Node Configuration:

  • Model: GPT-5
  • System: "You are a helpful customer support agent"
  • Prompt:
Analyze this email and determine:
1. Customer sentiment
2. Main issue
3. Urgency level

Email: {{input.body}}

3. Generate Response

Second Agent Node:

Based on this analysis: {{previousNode.output}}

Write a professional response to: {{input.body}}

Be helpful, empathetic, and provide clear next steps.

4. Send Reply

Email Action Node:

{
  "to": "{{input.from}}",
  "subject": "Re: {{input.subject}}",
  "body": "{{previousNode.output}}",
  "cc": "support-team@example.com"
}

Data Transformation

CSV to JSON Processing

Convert and enrich CSV data:

  1. Read CSV File
// Action Node: Parse CSV
const rows = parseCSV(input.csvData);
return { data: rows };
  1. Transform Each Row
// Loop + Action Node
return {
  id: generateId(),
  ...item,
  processed: true,
  timestamp: new Date().toISOString()
};
  1. Aggregate Results
// Join Node
return {
  total: input.length,
  processed: input,
  summary: generateSummary(input)
};

AI-Powered Workflows

Content Generation Pipeline

Create a complete content generation system:

1. Research Phase

Start → Agent (Research) → Extract Key Points

Research Prompt:

Research the topic: {{input.topic}}
Provide 5 key facts with sources.

2. Content Creation

Key Points → Fork → [Blog Post, Social Media, Email]

Blog Post Branch:

Write a 500-word blog post about {{input.topic}}
using these key points: {{research.keyPoints}}

Tone: Professional but engaging
Include: Introduction, 3 main sections, conclusion

Social Media Branch:

Create 3 social media posts about {{input.topic}}:
1. Twitter thread (3-5 tweets)
2. LinkedIn post (150 words)
3. Instagram caption (100 words)

Key points: {{research.keyPoints}}

3. Review and Publish

Join Results → Review Agent → Publish Actions

Sentiment Analysis Pipeline

Analyze customer feedback at scale:

  1. Collect Feedback

    • Source: API, Database, or File
    • Format: Array of feedback objects

  2. Parallel Analysis

Feedback → Fork → [Sentiment, Topics, Urgency]
  1. Sentiment Branch
Analyze sentiment (positive/negative/neutral):
{{input.feedback}}

Return: { sentiment: "...", score: 0-1 }
  1. Topic Extraction
Extract main topics and categories from:
{{input.feedback}}

Return: { topics: [...], categories: [...] }
  1. Urgency Detection
Determine urgency level (1-5) for:
{{input.feedback}}

Consider: Keywords, sentiment, explicit requests
  1. Aggregate and Act
// Join Node
const results = {
  feedback: input.original,
  sentiment: input.sentiment,
  topics: input.topics,
  urgency: input.urgency,
  action: determineAction(input)
};

// Route to appropriate team
if (results.urgency >= 4) {
  notifyUrgent(results);
}

Web Scraping

Automated Data Collection

Extract data from websites:

  1. Fetch Web Page
// Action Node: HTTP Request
{
  "method": "GET",
  "url": "{{input.targetUrl}}",
  "headers": {
    "User-Agent": "Mozilla/5.0..."
  }
}
  1. Extract Data
// Action Node: Parse HTML
const $ = cheerio.load(input.html);
const data = {
  title: $('h1').text(),
  price: $('.price').text(),
  description: $('.description').text(),
  images: $('img').map((i, el) => $(el).attr('src')).get()
};
return data;
  1. Process with AI
Summarize this product information:
{{extractedData}}

Include: Key features, price analysis, recommendations

Advanced Patterns

Error Handling Pattern

Build robust workflows with error handling:

Try Block → [Success Path]
         → [Error Handler] → Log → Notify → Recover

Retry Pattern

Implement automatic retries:

// Loop Node with retry logic
{
  "maxRetries": 3,
  "backoff": "exponential",
  "condition": "output.success === false"
}

Circuit Breaker Pattern

Prevent cascade failures:

// Condition Node
if (failureCount > threshold) {
  return { circuitOpen: true, fallback: true };
}

Best Practices

1. Start Simple

  • Test each node individually
  • Build incrementally
  • Use sample data

2. Handle Edge Cases

  • Check for null/undefined
  • Validate data formats
  • Plan for API failures

3. Optimize Performance

  • Use parallel processing
  • Cache when possible
  • Minimize API calls

4. Document Your Workflows

  • Name nodes descriptively
  • Add comments in complex logic
  • Document expected inputs/outputs

Next Steps