Core Concepts

id: customer-support
version: 0.1.0
description: Handle customer inquiries with AI agents

config:
  input:
    type: object
    properties:
      customer_message:
        type: string
      customer_id:
        type: string

tasks:
  - id: classify_intent
    type: basic
    # ... task definition

  - id: generate_response
    type: basic
    # ... task definition

resource: agent
id: customer_service_agent
version: 0.1.0

config:
  provider: groq
  model: llama-3.3-70b-versatile
  api_key: "{{ .env.GROQ_API_KEY }}"

instructions: |
  You are a helpful customer service agent. Your role is to:
  - Understand customer inquiries and classify their intent
  - Provide accurate, helpful responses
  - Escalate complex issues when necessary
  Always maintain a professional, friendly tone.

tools:
  - $ref: local::tools.#(id=="knowledge_base")
  - $ref: local::tools.#(id=="ticket_system")

actions:
  - id: classify_intent
    prompt: |
      Analyze this customer message: "{{ .input.message }}"
      Classify the intent as: question, complaint, request, or compliment.
    output:
      type: object
      properties:
        intent:
          type: string
          enum: [question, complaint, request, compliment]
        confidence:
          type: number
        reasoning:
          type: string

  - id: generate_response
    json_mode: true
    prompt: |
      Based on the customer's message and intent:
      Message: {{ .input.message }}
      Intent: {{ .input.intent }}

      Generate an appropriate response that addresses their needs.

interface WeatherInput {
  location: string;
  units?: "metric" | "imperial";
}

interface WeatherOutput {
  temperature: number;
  description: string;
  humidity: number;
  location: string;
  success: boolean;
}

export async function weatherTool({ input }: { input: WeatherInput }): Promise<WeatherOutput> {
  const { location, units = "metric" } = input;

  try {
    // Use OpenWeatherMap API (requires API key in environment)
    const apiKey = process.env.OPENWEATHER_API_KEY;
    if (!apiKey) {
      throw new Error("OpenWeatherMap API key not found in environment");
    }

    const response = await fetch(
      `https://api.openweathermap.org/data/2.5/weather?q=${encodeURIComponent(location)}&appid=${apiKey}&units=${units}`
    );

    if (!response.ok) {
      throw new Error(`Weather API request failed: ${response.status}`);
    }

    const data = await response.json();

    return {
      temperature: Math.round(data.main.temp),
      description: data.weather[0].description,
      humidity: data.main.humidity,
      location: data.name,
      success: true,
    };
  } catch (error: any) {
    throw new Error(`Weather lookup failed: ${error.message}`);
  }
}

tools:
  - id: weather_tool
    description: Fetches current weather data for a given location
    input:
      type: object
      properties:
        location:
          type: string
          description: City name or location to get weather for
        units:
          type: string
          enum: ["metric", "imperial"]
          description: Temperature units (metric or imperial)
          default: metric
      required:
        - location

# Configure memory in your project
memory:
  provider: redis
  config:
    url: "{{ .env.REDIS_URL }}"
  strategies:
    conversation:
      type: token_lru
      max_tokens: 4000
      eviction_policy: lru
    facts:
      type: fifo
      max_entries: 100

# Emitting a signal in a workflow
tasks:
  - id: process_order
    type: basic
    $use: agent(local::agents.#(id=="order_processor"))
    with:
      order: "{{ .workflow.input.order }}"
    on_success:
      next: notify_completion

  - id: notify_completion
    type: signal
    signal:
      id: order-processed
      payload:
        order_id: "{{ .workflow.input.order.id }}"
        status: "completed"
        timestamp: "{{ now }}"

# Receiving signals in another workflow
  - id: wait_for_order
    type: wait
    wait_for: "order-processed"
    timeout: 300s
    condition: '{{ eq .signal.payload.status "completed" }}'
    on_success:
      next: send_notification

# Configure MCP servers in your project
mcps:
  - id: filesystem
    transport: stdio
    command: "mcp-server-filesystem"
    args: ["--root", "/workspace"]

  - id: github
    transport: http
    endpoint: "http://localhost:3000/mcp"
    headers:
      Authorization: "Bearer {{ .env.GITHUB_TOKEN }}"

# Use MCP tools in agents
agents:
  - id: developer_agent
    config:
      provider: groq
      model: llama-3.3-70b-versatile
    instructions: |
      You are a developer assistant with access to filesystem and GitHub tools.
      Use the available MCP tools to read files, make changes, and interact with repositories.

    # MCP tools are automatically discovered and available
    actions:
      - id: analyze_codebase
        prompt: |
          Analyze the project structure in /workspace and provide insights.
          Use filesystem tools to explore the codebase.

# Access workflow input
with:
  message: "{{ .workflow.input.message }}"

# Access previous task outputs
condition: "{{ .tasks.classify.output.category }}"

# Transform data
formatted_data: "{{ .tasks.process.output | toJson }}"

# Conditional logic
status: |
  {{ if eq .tasks.validate.output.valid true }}
  approved
  {{ else }}
  rejected
  {{ end }}

# Current timestamp
timestamp: "{{ now }}"

# Array operations
count: "{{ len .tasks.collection.output }}"
first_item: "{{ index .tasks.collection.output 0 }}"

# Collection item access
item_value: "{{ .item }}"
item_index: "{{ .index }}"