Real-World Advanced App Examples

Learn advanced Fiberwise app development through two comprehensive examples that demonstrate enterprise-grade features including AI automation, complex workflows, and sophisticated user interfaces.

Document Processing Application

A complete AI-powered document processing system with file uploads, intelligent data extraction, and approval workflows.

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│  User Uploads   │────│  File Storage   │────│  AI Analysis    │
│   Document      │    │  (Fiberwise)    │    │   (LLM Agent)   │
└─────────────────┘    └─────────────────┘    └─────────────────┘
         │                       │                       │
         ▼                       ▼                       ▼
┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│ Status: uploaded│────│Status: processing│───│Status: completed│
│   (Dashboard)   │    │   (Real-time)   │    │  (With Results) │
└─────────────────┘    └─────────────────┘    └─────────────────┘
         │                       │                       │
         ▼                       ▼                       ▼
┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│  User Reviews   │────│  AI Extracted   │────│   Final Data    │
│   on Dashboard  │    │   Structured    │    │   Stored in     │
│                 │    │      Data       │    │     Model       │
└─────────────────┘    └─────────────────┘    └─────────────────┘

Complete App Manifest

# app_manifest.yaml - Advanced Document Processor
app:
  name: Document Processor
  app_slug: doc-processor
  version: 1.0.0
  description: AI-powered document processing with real-time status
  entryPoint: index.js
  icon: fas fa-file-alt
  category: productivity

  models:
    - name: Document
      model_slug: documents
      user_isolation: enforced
      fields:
        - name: ID
          field_column: id
          type: uuid
          is_primary_key: true
        - name: Filename
          field_column: filename
          type: string
          required: true
        - name: Status
          field_column: status
          type: string
          default: "uploaded"
          validations:
            enum: ["uploaded", "processing", "completed", "failed"]
        - name: Document Type
          field_column: doc_type
          type: string
          description: "AI-determined document category"
        - name: Extracted Data
          field_column: extracted_data
          type: json
          description: "AI-extracted structured data"
        - name: Processing Notes
          field_column: notes
          type: text
        - name: Confidence Score
          field_column: confidence
          type: decimal
        - name: Created At
          field_column: created_at
          type: timestamp
          default: CURRENT_TIMESTAMP
          is_system_field: true

  routes:
    - path: /
      component: document-dashboard
      title: Dashboard
      icon: fas fa-tachometer-alt
    - path: /upload
      component: document-upload
      title: Upload
      icon: fas fa-cloud-upload-alt
    - path: /documents/:id
      component: document-detail
      title: Document Details
      icon: fas fa-file-alt

agents:
  - name: documentAnalyzer
    description: Analyze and extract data from documents
    agent_type_id: llm
    version: 1.0.0
    input_schema:
      type: object
      properties:
        filename:
          type: string
        content_preview:
          type: string
    output_schema:
      type: object
      properties:
        document_type:
          type: string
          enum: ["invoice", "contract", "receipt", "form", "other"]
        confidence:
          type: number
        extracted_fields:
          type: object
        summary:
          type: string

functions:
  - name: processDocument
    description: Process uploaded document with AI analysis
    version: 1.0.0
    input_schema:
      type: object
      properties:
        document_id:
          type: string
    output_schema:
      type: object
      properties:
        success:
          type: boolean
        processing_id:
          type: string
        estimated_completion:
          type: string

pipelines:
  - id: document_processing_pipeline
    name: Document Processing Pipeline
    description: Complete document analysis and data extraction workflow
    trigger:
      type: data_change
      model: documents
      conditions:
        - field: status
          operator: equals
          value: "uploaded"
    
    steps:
      - id: analyze_document
        name: AI Document Analysis
        type: agent_activation
        agent_id: documentAnalyzer
        input_mapping:
          filename: "${trigger.data.filename}"
          content_preview: "${trigger.data.content_preview}"
        
      - id: update_results
        name: Update Document with Results
        type: data_update
        model: documents
        item_id: "${trigger.item_id}"
        data:
          doc_type: "${steps.analyze_document.output.document_type}"
          confidence: "${steps.analyze_document.output.confidence}"
          extracted_data: "${steps.analyze_document.output.extracted_fields}"
          status: "completed"
          notes: "${steps.analyze_document.output.summary}"

Key Features Demonstrated

Enterprise Customer Support System

A complete enterprise support system with external API integration, AI processing, and human workflow management.

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   External API  │────│  Fiberwise API  │────│   Support App   │
│  (Python SDK)   │    │   (REST/WS)     │    │  (Dashboard)    │
└─────────────────┘    └─────────────────┘    └─────────────────┘
         │                       │                       │
         ▼                       ▼                       ▼
┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│ Support Tickets │────│   AI Agents     │────│ Human Agents    │
│   (Model Data)  │    │ (Classification)│    │  (Dashboard)    │
└─────────────────┘    └─────────────────┘    └─────────────────┘
         │                       │                       │
         ▼                       ▼                       ▼
┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   Pipelines     │────│   Workflows     │────│  Notifications  │
│  (Automation)   │    │ (Human Steps)   │    │   (Real-time)   │
└─────────────────┘    └─────────────────┘    └─────────────────┘

Complete Support System Manifest

# app_manifest.yaml - Enterprise Support System
app:
  name: Customer Support Portal
  app_slug: support-portal
  version: 2.0.0
  description: Enterprise customer support system with AI automation and human workflows
  entryPoint: index.js
  icon: fas fa-headset
  category: customer_service

  models:
    - name: Support Ticket
      model_slug: support_tickets
      user_isolation: enforced
      fields:
        - name: ID
          field_column: id
          type: uuid
          is_primary_key: true
        - name: Customer Email
          field_column: customer_email
          type: string
          required: true
          validations:
            format: email
        - name: Subject
          field_column: subject
          type: string
          required: true
          validations:
            max_length: 200
        - name: Description
          field_column: description
          type: text
          required: true
        - name: Status
          field_column: status
          type: string
          default: "new"
          validations:
            enum: ["new", "processing", "waiting_review", "resolved", "closed"]
        - name: Priority
          field_column: priority
          type: string
          default: "medium"
          validations:
            enum: ["low", "medium", "high", "urgent"]
        - name: Category
          field_column: category
          type: string
          validations:
            enum: ["technical", "billing", "general", "urgent", "feature_request"]
        - name: AI Response
          field_column: ai_response
          type: text
          description: "Generated AI response"
        - name: Human Response
          field_column: human_response
          type: text
          description: "Final approved response"
        - name: Sentiment Score
          field_column: sentiment_score
          type: decimal
          description: "Customer sentiment analysis result"
        - name: Confidence Score
          field_column: confidence_score
          type: decimal
          description: "AI classification confidence"
        - name: Escalation Required
          field_column: escalation_required
          type: boolean
          default: false
        - name: Assigned Agent
          field_column: assigned_agent
          type: string
          description: "Human agent assigned to ticket"
        - name: Resolution Time
          field_column: resolution_time
          type: timestamp
          description: "When ticket was resolved"
        - name: Customer Satisfaction
          field_column: satisfaction_rating
          type: integer
          validations:
            min: 1
            max: 5
        - name: Created At
          field_column: created_at
          type: timestamp
          default: CURRENT_TIMESTAMP
          is_system_field: true

  routes:
    - path: /
      component: support-dashboard
      title: Support Dashboard
      icon: fas fa-tachometer-alt
    - path: /tickets
      component: ticket-list
      title: All Tickets
      icon: fas fa-list
    - path: /tickets/:id
      component: ticket-detail
      title: Ticket Details
      icon: fas fa-ticket-alt
    - path: /analytics
      component: support-analytics
      title: Analytics
      icon: fas fa-chart-bar

agents:
  - name: ticketClassifier
    description: Classify and prioritize support tickets
    agent_type_id: llm
    version: 1.0.0
    input_schema:
      type: object
      properties:
        subject:
          type: string
        description:
          type: string
        customer_email:
          type: string
    output_schema:
      type: object
      properties:
        category:
          type: string
          enum: ["technical", "billing", "general", "urgent", "feature_request"]
        priority:
          type: string
          enum: ["low", "medium", "high", "urgent"]
        confidence:
          type: number
        reasoning:
          type: string

  - name: sentimentAnalyzer
    description: Analyze customer sentiment and urgency
    agent_type_id: llm
    version: 1.0.0
    input_schema:
      type: object
      properties:
        ticket_content:
          type: string
    output_schema:
      type: object
      properties:
        sentiment:
          type: string
          enum: ["positive", "neutral", "negative", "frustrated", "angry"]
        urgency_indicators:
          type: array
        satisfaction_risk:
          type: string
          enum: ["low", "medium", "high", "critical"]

  - name: responseGenerator
    description: Generate AI responses for support tickets
    agent_type_id: llm
    version: 1.0.0
    input_schema:
      type: object
      properties:
        ticket:
          type: object
        classification:
          type: object
        company_context:
          type: object
    output_schema:
      type: object
      properties:
        response_text:
          type: string
        requires_human_review:
          type: boolean
        suggested_actions:
          type: array
        escalation_needed:
          type: boolean

functions:
  - name: createTicketFromAPI
    description: Create support ticket from external API call
    version: 1.0.0
    input_schema:
      type: object
      properties:
        customer_email:
          type: string
        subject:
          type: string
        description:
          type: string
        source:
          type: string
    output_schema:
      type: object
      properties:
        success:
          type: boolean
        ticket_id:
          type: string
        processing_started:
          type: boolean

pipelines:
  - id: new_ticket_processing
    name: New Ticket AI Processing
    description: Complete AI processing workflow for new support tickets
    trigger:
      type: data_change
      model: support_tickets
      conditions:
        - field: status
          operator: equals
          value: "new"
    
    steps:
      - id: classify_ticket
        name: Classify and Prioritize
        type: agent_activation
        agent_id: ticketClassifier
        input_mapping:
          subject: "${trigger.data.subject}"
          description: "${trigger.data.description}"
          customer_email: "${trigger.data.customer_email}"
        
      - id: analyze_sentiment
        name: Sentiment Analysis
        type: agent_activation
        agent_id: sentimentAnalyzer
        input_mapping:
          ticket_content: "${trigger.data.subject} ${trigger.data.description}"
        
      - id: generate_response
        name: Generate AI Response
        type: agent_activation
        agent_id: responseGenerator
        input_mapping:
          ticket: "${trigger}"
          classification: "${steps.classify_ticket.output}"
          company_context: {}
        
      - id: update_ticket_ai_data
        name: Update Ticket with AI Results
        type: data_update
        model: support_tickets
        item_id: "${trigger.item_id}"
        data:
          category: "${steps.classify_ticket.output.category}"
          priority: "${steps.classify_ticket.output.priority}"
          confidence_score: "${steps.classify_ticket.output.confidence}"
          sentiment_score: "${steps.analyze_sentiment.output.sentiment}"
          ai_response: "${steps.generate_response.output.response_text}"
          escalation_required: "${steps.generate_response.output.escalation_needed}"
          status: "${steps.generate_response.output.requires_human_review ? 'waiting_review' : 'processing'}"

# Human-in-the-Loop Workflows
workflows:
  - id: response_approval_workflow
    name: AI Response Review & Approval
    description: Human review process for AI-generated responses
    trigger:
      type: data_change
      model: support_tickets
      conditions:
        - field: status
          operator: equals
          value: "waiting_review"
    
    steps:
      - id: assign_to_agent
        name: Assign to Human Agent
        type: human_task
        assignee_type: role
        assignee_value: "support_agent"
        task_data:
          title: "Review AI Response for Ticket"
          description: "Please review the AI-generated response and approve or modify as needed"
          ticket_id: "${trigger.item_id}"
          ai_response: "${trigger.data.ai_response}"
          customer_email: "${trigger.data.customer_email}"
          priority: "${trigger.data.priority}"
        
        actions:
          - id: approve_response
            label: "Approve & Send"
            type: data_update
            model: support_tickets
            item_id: "${trigger.item_id}"
            data:
              human_response: "${trigger.data.ai_response}"
              status: "resolved"
              assigned_agent: "${action.user_id}"
              resolution_time: "${now()}"
            
          - id: modify_response
            label: "Modify Response"
            type: form_input
            fields:
              - name: modified_response
                type: textarea
                label: "Modified Response"
                default: "${trigger.data.ai_response}"
                required: true
            
            on_submit:
              type: data_update
              model: support_tickets
              item_id: "${trigger.item_id}"
              data:
                human_response: "${action.form.modified_response}"
                status: "resolved"
                assigned_agent: "${action.user_id}"
                resolution_time: "${now()}"
          
          - id: escalate_ticket
            label: "Escalate to Senior"
            type: data_update
            model: support_tickets
            item_id: "${trigger.item_id}"
            data:
              status: "escalated"
              escalation_required: true
              assigned_agent: "${action.user_id}"

Advanced Features Demonstrated

Python Agent Implementations

Here are the actual Python implementation files for the LLM agents defined in the manifest. These provide proper prompts and business logic for automated support ticket processing:

# Core response generation with context
async def run(self, input_data: Dict[str, Any]) -> Dict[str, Any]:
    """Generate contextual support response with AI and business logic"""
    
    # Extract ticket and classification data
    ticket = input_data.get('ticket', {})
    classification = input_data.get('classification', {})
    
    # Get customer context for personalization
    customer_context = await self._get_customer_context(customer_email)
    
    # Build comprehensive prompt with company policies
    response_prompt = self._build_response_prompt(
        ticket_data, classification, customer_context, company_context
    )
    
    # Generate response using LLM with fallback
    llm_response = await self._generate_llm_response(response_prompt)
    
    # Determine human review requirements
    requires_review = self._requires_human_review(
        category, priority, sentiment, confidence, processed_response
    )
    
    return {
        "response_text": processed_response,
        "requires_human_review": requires_review,
        "suggested_actions": suggested_actions,
        "escalation_needed": escalation_needed,
        "confidence_score": confidence
    }

# Hybrid classification approach
def _combine_classifications(self, rule_based: Dict, llm_based: Dict, 
                           customer_context: Dict) -> Dict[str, Any]:
    """Combine rule-based and LLM results intelligently"""
    
    # Start with rule-based baseline
    final_category = rule_based['category']
    final_confidence = rule_based['confidence']
    
    # Override with LLM if higher confidence
    if llm_based.get('confidence', 0) > final_confidence:
        final_category = llm_based.get('category', final_category)
        final_confidence = llm_based.get('confidence', final_confidence)
    
    # Premium customer tier adjustments
    if customer_context.get('tier') == 'premium':
        if final_priority == 'low':
            final_priority = 'medium'
        final_confidence = min(final_confidence + 0.1, 1.0)
    
    return final_classification

# Advanced sentiment analysis
def _assess_satisfaction_risk(self, sentiment_data: Dict, 
                            urgency_indicators: List, escalation_risk: str) -> str:
    """Assess customer satisfaction risk level"""
    
    risk_factors = 0
    
    # Sentiment-based risk factors
    if sentiment_data['sentiment'] in ['negative', 'frustrated', 'angry']:
        risk_factors += 2
    
    # Urgency indicators increase risk
    if urgency_indicators:
        risk_factors += len(urgency_indicators)
    
    # Escalation indicators
    if escalation_risk == 'high':
        risk_factors += 3
    
    # Return risk assessment
    if risk_factors >= 5:
        return 'critical'
    elif risk_factors >= 3:
        return 'high'
    elif risk_factors >= 1:
        return 'medium'
    else:
        return 'low'

External API Integration

Python SDK Integration with API Keys

Here's how external systems can create support tickets using the Fiberwise Python SDK with proper API key authentication:

# external_support_integration.py
"""
External system integration for creating support tickets
via Fiberwise API using proper authentication
"""

import asyncio
from fiberwise import FiberwiseClient
from typing import Dict, Any, Optional

class SupportTicketIntegration:
    """
    Integration class for creating support tickets from external systems
    """
    
    def __init__(self, api_key: str, app_slug: str, base_url: str = "https://api.fiberwise.ai"):
        """
        Initialize with API credentials
        
        Args:
            api_key: Your Fiberwise API key
            app_slug: The support portal app slug
            base_url: Fiberwise API base URL
        """
        self.client = FiberwiseClient(
            api_key=api_key,
            base_url=base_url
        )
        self.app_slug = app_slug

    async def create_support_ticket(self, 
                                  customer_email: str,
                                  subject: str, 
                                  description: str,
                                  source: str = "external_api",
                                  metadata: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
        """
        Create a new support ticket that will be processed by AI agents
        
        Args:
            customer_email: Customer's email address
            subject: Ticket subject line
            description: Detailed description of the issue
            source: Source system identifier
            metadata: Additional metadata for the ticket
            
        Returns:
            Created ticket data with processing status
        """
        try:
            # Create the support ticket using Fiberwise data API
            ticket_data = {
                "customer_email": customer_email,
                "subject": subject,
                "description": description,
                "status": "new",  # Will trigger AI processing pipeline
                "source": source,
                "metadata": metadata or {}
            }
            
            # Call the createTicketFromAPI function
            result = await self.client.functions.invoke(
                app_slug=self.app_slug,
                function_name="createTicketFromAPI",
                input_data=ticket_data
            )
            
            if result.get('success'):
                ticket_id = result.get('ticket_id')
                
                # Wait briefly for AI processing to start
                await asyncio.sleep(1)
                
                # Get the updated ticket with AI analysis
                ticket = await self.client.data.get_item(
                    app_slug=self.app_slug,
                    model_slug="support_tickets",
                    item_id=ticket_id
                )
                
                return {
                    "success": True,
                    "ticket_id": ticket_id,
                    "ticket_data": ticket,
                    "ai_processing_started": result.get('processing_started', False),
                    "classification": {
                        "category": ticket.get('data', {}).get('category'),
                        "priority": ticket.get('data', {}).get('priority'),
                        "confidence": ticket.get('data', {}).get('confidence_score')
                    }
                }
            else:
                return {
                    "success": False,
                    "error": result.get('error', 'Unknown error creating ticket')
                }
                
        except Exception as e:
            return {
                "success": False,
                "error": f"Integration error: {str(e)}"
            }

    async def get_ticket_status(self, ticket_id: str) -> Dict[str, Any]:
        """
        Get current status and AI analysis results for a ticket
        
        Args:
            ticket_id: The ticket ID to check
            
        Returns:
            Current ticket status and AI results
        """
        try:
            ticket = await self.client.data.get_item(
                app_slug=self.app_slug,
                model_slug="support_tickets", 
                item_id=ticket_id
            )
            
            ticket_data = ticket.get('data', {})
            
            return {
                "success": True,
                "ticket_id": ticket_id,
                "status": ticket_data.get('status'),
                "priority": ticket_data.get('priority'),
                "category": ticket_data.get('category'),
                "ai_response": ticket_data.get('ai_response'),
                "human_response": ticket_data.get('human_response'),
                "escalation_required": ticket_data.get('escalation_required'),
                "assigned_agent": ticket_data.get('assigned_agent'),
                "sentiment_score": ticket_data.get('sentiment_score'),
                "confidence_score": ticket_data.get('confidence_score'),
                "resolution_time": ticket_data.get('resolution_time'),
                "satisfaction_rating": ticket_data.get('satisfaction_rating')
            }
            
        except Exception as e:
            return {
                "success": False,
                "error": f"Error retrieving ticket: {str(e)}"
            }

    async def bulk_create_tickets(self, tickets: list) -> Dict[str, Any]:
        """
        Create multiple support tickets efficiently
        
        Args:
            tickets: List of ticket dictionaries with customer_email, subject, description
            
        Returns:
            Bulk creation results with success/failure counts
        """
        results = []
        successful = 0
        failed = 0
        
        # Process tickets concurrently for efficiency
        tasks = []
        for ticket in tickets:
            task = self.create_support_ticket(
                customer_email=ticket['customer_email'],
                subject=ticket['subject'],
                description=ticket['description'],
                source=ticket.get('source', 'bulk_import'),
                metadata=ticket.get('metadata')
            )
            tasks.append(task)
        
        # Execute all tasks concurrently
        results = await asyncio.gather(*tasks, return_exceptions=True)
        
        # Count successes and failures
        for result in results:
            if isinstance(result, dict) and result.get('success'):
                successful += 1
            else:
                failed += 1
        
        return {
            "total_processed": len(tickets),
            "successful": successful,
            "failed": failed,
            "results": results
        }

# Example usage
async def main():
    """Example integration usage"""
    
    # Initialize with your API credentials
    integration = SupportTicketIntegration(
        api_key="your_api_key_here",
        app_slug="support-portal"
    )
    
    # Create a single support ticket
    result = await integration.create_support_ticket(
        customer_email="[email protected]",
        subject="Login Issues After Update",
        description="I cannot log into my account after the latest app update. Getting 'invalid credentials' error even with correct password.",
        source="mobile_app",
        metadata={"app_version": "2.1.3", "device": "iOS"}
    )
    
    if result['success']:
        print(f"Ticket created: {result['ticket_id']}")
        print(f"AI Classification: {result['classification']}")
        
        # Check status after some processing time
        await asyncio.sleep(5)
        
        status = await integration.get_ticket_status(result['ticket_id'])
        print(f"Current status: {status['status']}")
        print(f"AI Response: {status['ai_response']}")
    else:
        print(f"Failed to create ticket: {result['error']}")

if __name__ == "__main__":
    asyncio.run(main())

Advanced Development Patterns

Next Steps