Building Advanced AI Voice Agents with the SignalWire AI Agents SDK 🔗 ↑ TOC

sw-search docs/ --output knowledge.swsearch

class MyAgent(AgentBase):
    def __init__(self):
        super().__init__(name="My Agent")
        self.add_skill("web_search", {
            "api_key": "your-google-api-key",
            "search_engine_id": "your-search-engine-id",
            "num_results": 3
        })
        self.add_skill("datetime")
        self.add_skill("math")
        self.add_skill("native_vector_search", {"index_file": "knowledge.swsearch"})

from signalwire_agents.core.data_map import DataMap
from signalwire_agents.core.function_result import SwaigFunctionResult

weather_tool = (DataMap('get_weather')
    .parameter('location', 'string', 'City name', required=True)
    .webhook('GET', 'https://api.weather.com/v1/current?key=API_KEY&q=${location}')
    .output(SwaigFunctionResult('Weather: ${response.current.temp_f}°F'))
)

sw-search docs/ --output knowledge.swsearch

class AgentBase:
    def __init__(
        self,
        name: str,
        route: str = "/",
        host: str = "0.0.0.0", 
        port: int = 3000,
        basic_auth: Optional[Tuple[str, str]] = None,
        use_pom: bool = True,
        enable_state_tracking: bool = False,
        token_expiry_secs: int = 3600,
        auto_answer: bool = True,
        record_call: bool = False,
        record_format: str = "mp4",
        record_stereo: bool = True,
        state_manager: Optional[StateManager] = None,
        default_webhook_url: Optional[str] = None,
        agent_id: Optional[str] = None,
        native_functions: Optional[List[str]] = None,
        schema_path: Optional[str] = None,
        suppress_logs: bool = False,
        enable_post_prompt_override: bool = False,
        check_for_input_override: bool = False
    ):
        # Core initialization with all parameters

    def set_prompt_text(self, prompt: str):
        # Define the agent's personality and capabilities

    def add_skill(self, skill_name: str, params: Optional[Dict[str, Any]] = None):
        # Register skills with optional configuration

    def register_swaig_function(self, function_dict: Dict[str, Any]):
        # Register SWAIG functions (including DataMap tools)

    @classmethod
    def tool(cls, name=None, **kwargs):
        # SWAIG function decorator for custom business logic
        def decorator(func):
            # Function implementation
            pass

# Automatic endpoint creation
router.get("/") and router.post("/")                    # Main conversation endpoint
router.get("/debug") and router.post("/debug")          # Debug endpoint
router.get("/swaig") and router.post("/swaig")          # SWAIG function call endpoint
router.get("/post_prompt") and router.post("/post_prompt")  # Post-prompt endpoint
router.get("/check_for_input") and router.post("/check_for_input")  # Input check endpoint
app.get("/health") and app.post("/health")              # Health check endpoint
app.get("/ready") and app.post("/ready")                # Readiness check endpoint

# Skills can be added with specific configurations
agent.add_skill("web_search", {
    "api_key": "your-google-api-key",
    "search_engine_id": "your-search-engine-id",
    "num_results": 10
})

# Same skill, different configuration for news
agent.add_skill("web_search", {
    "api_key": "your-google-api-key",
    "search_engine_id": "news-engine-id", 
    "num_results": 3,
    "tool_name": "news_search"
})

# Variable expansion patterns supported:
# ${field}             - Direct parameter access from function arguments

# Global web search configuration
default_web_config = {
    "max_results": 5,
    "safe_search": "strict",
    "timeout": 10
}

# Specific instance overrides
agent.add_skill("web_search", {
    **default_web_config,
    "search_engine_id": "docs-engine-id",
    "max_results": 3  # Override global setting
})

user_lookup = (DataMap('lookup_user')
    .parameter('user_id', 'string', 'User identifier', required=True)
    .parameter('include_history', 'boolean', 'Include user history')
    .webhook('GET', 'https://api.example.com/users/${args.user_id}?history=${args.include_history}',
             headers={'Authorization': 'Bearer ${global_data.API_TOKEN}'})
    .output(SwaigFunctionResult("""
        User Information:
        Name: ${response.full_name}
        Email: ${response.email_address}
        Last Login: ${response.last_activity.login_time}
    """))
    .error_keys(['error', 'message'])
    .fallback_output(SwaigFunctionResult("Unable to retrieve user information."))
)

# Expression-based conditional responses
.expression('${response.status}', r'active', 
    SwaigFunctionResult('✅ Account Status: Active. Subscription expires: ${response.subscription.expires}'))
.expression('${response.status}', r'suspended',
    SwaigFunctionResult('⚠️ Account Status: Suspended. Reason: ${response.suspension_reason}. Contact support to reactivate.'))
.output(SwaigFunctionResult('⚠️ Account Status: ${response.status}'))

.swsearch file format:
├── Metadata Layer
│   ├── Document count and statistics
│   ├── Index creation parameters
│   └── Version compatibility information
├── Vector Layer
│   ├── Sentence-level embeddings
│   ├── Paragraph-level embeddings
│   └── Document-level embeddings
├── Keyword Layer
│   ├── Inverted index for exact matches
│   ├── n-gram indexes for partial matches
│   └── Stemmed word indexes for linguistic variants
└── Document Store
    ├── Original document content
    ├── Processed text segments
    └── Metadata and source information

HTTP Request → Authentication → Request Parsing → Context Assembly

Context + Available Functions → AI Processing → Function Selection + Parameters

Function Call → Parameter Validation → Execution (Skills/DataMap/SWAIG) → Result Processing

Function Results + AI Context → Response Generation → Output Formatting → HTTP Response

@AgentBase.tool(name="start_order_process")
def start_order_process(self, args, raw_data):
    # Initialize order state
    order_data = {
        "order_id": generate_order_id(),
        "items": [],
        "customer_info": {},
        "step": "collecting_items"
    }

    result = SwaigFunctionResult("Let's start your order! What would you like to add?")

    # Store state in global data for AI access
    result.add_action("set_global_data", {
        "current_order": order_data
    })

    return result

@AgentBase.tool(name="add_item_to_order")
def add_item_to_order(self, args, raw_data):
    # Retrieve current state
    current_order = self.get_global_data("current_order", {})

    if not current_order:
        return SwaigFunctionResult("I don't see an active order. Let me start a new one for you.")

    # Update state with new item
    current_order["items"].append({
        "sku": args.get("item_sku"),
        "quantity": args.get("quantity", 1),
        "added_at": datetime.now().isoformat()
    })

    result = SwaigFunctionResult(f"Added {args.get('quantity', 1)} {args.get('item_name')} to your order.")

    # Update stored state
    result.add_action("set_global_data", {
        "current_order": current_order
    })

    return result

AgentBase (Abstract base class)
├── Agent (Main implementation)
│   ├── Skills integration
│   ├── DataMap tools support
│   ├── Local search capabilities
│   └── SWAIG function handling
├── InfoGathererAgent (Prefab)
├── FAQBotAgent (Prefab)
├── ConciergeAgent (Prefab)
└── SurveyAgent (Prefab)

pip install signalwire-agents

pip install "signalwire-agents[search]"

pip install "signalwire-agents[search-full]"

pip install "signalwire-agents[search-nlp]"

python -m spacy download en_core_web_sm

pip install "signalwire-agents[search-all]"

python -m spacy download en_core_web_sm

git clone https://github.com/signalwire/signalwire-python.git
cd signalwire-python
pip install -e ".[search]"

try:
    from signalwire_agents.search import IndexBuilder, SearchEngine
    print("✅ Search functionality is available")
except ImportError as e:
    print(f"❌ Search not available: {e}")
    print("Install with: pip install signalwire-agents[search]")

export PYTORCH_DISABLE_AVX2=1
export PYTORCH_DISABLE_AVX512=1

PYTORCH_DISABLE_AVX2=1 PYTORCH_DISABLE_AVX512=1 pip install signalwire-agents[search]

export SIGNALWIRE_PROJECT_ID="your-project-id"
export SIGNALWIRE_TOKEN="your-auth-token"
export SIGNALWIRE_SPACE="your-space-name.signalwire.com"

# For web search skill (if using external search APIs)
export SEARCH_API_KEY="your-search-api-key"

# For custom authentication
export AGENT_AUTH_TOKEN="your-custom-token"

# For development
export FLASK_ENV="development"
export FLASK_DEBUG="1"

python -c "import signalwire_agents; print('SDK installed successfully')"

sw-search --help

my-agent/
├── agent.py              # Main agent implementation
├── requirements.txt      # Dependencies
├── .env                 # Environment variables
├── knowledge/           # Documents for search indexing
│   ├── docs/
│   └── faqs/
├── indexes/             # Generated search indexes
│   └── knowledge.swsearch
└── README.md           # Project documentation

from signalwire_agents import AgentBase

class QuickStartAssistant(AgentBase):
    def __init__(self):
        super().__init__(name="QuickStart Assistant")
        self.set_prompt_text("You are a helpful assistant that can answer questions and provide information.")

agent = QuickStartAssistant()

if __name__ == "__main__":
    agent.run()

from signalwire_agents import AgentBase

class EnhancedAssistant(AgentBase):
    def __init__(self):
        super().__init__(name="Enhanced Assistant")
        self.set_prompt_text(
            "You are a knowledgeable assistant that can help with questions, "
            "search the internet for current information, and provide date/time details."
        )

        # Add skills to enhance the agent's capabilities
        self.add_skill("web_search", {
            "api_key": "your-google-api-key",
            "search_engine_id": "your-search-engine-id",
            "num_results": 3,
            "delay": 0.5
        })

        self.add_skill("datetime")

        self.add_skill("math")

agent = EnhancedAssistant()

if __name__ == "__main__":
    agent.run()

agent.add_skill("web_search", {
    "api_key": "your-google-api-key",           # Google API key
    "search_engine_id": "your-search-engine-id", # Google Search Engine ID
    "num_results": 5,                    # Number of search results to retrieve
    "delay": 0.5                         # Delay between requests
})

agent.add_skill("datetime")  # Datetime skill uses simple configuration

agent.add_skill("math")  # Math skill works with default settings - no configuration needed

# General web search
agent.add_skill("web_search", {
    "api_key": "your-google-api-key",
    "search_engine_id": "your-search-engine-id",
    "num_results": 3
})

# Detailed research search
agent.add_skill("web_search", {
    "api_key": "your-google-api-key",
    "search_engine_id": "your-search-engine-id",
    "num_results": 10,
    "max_content_length": 2000,
    "tool_name": "research_search"
})

# Quick fact checking
agent.add_skill("web_search", {
    "api_key": "your-google-api-key", 
    "search_engine_id": "your-search-engine-id",
    "num_results": 1,
    "max_content_length": 200,
    "tool_name": "fact_check"
})

# First, create a search index from your documents
# Run this command in your terminal:
# sw-search docs/ --output knowledge.swsearch

# Then add the search skill to your agent
agent.add_skill("native_vector_search", {
    "index_file": "knowledge.swsearch",
    "count": 5,
    "distance_threshold": 0.7
})

python agent.py

 * Agent 'Enhanced Assistant' running on http://0.0.0.0:5000
 * Available skills: web_search, datetime, math
 * Authentication: Basic (username: 8A7B9C, password: X3R8K9)

agent.add_skill("web_search")

agent.add_skill("web_search", {
    "api_key": "your-google-api-key",           # Google Custom Search API key
    "search_engine_id": "your-search-engine-id", # Google Search Engine ID  
    "num_results": 5,                    # Number of search results (1-10)
    "delay": 1.0,                        # Delay between requests in seconds
    "no_results_message": "Sorry, I couldn't find information about '{query}'. Try a different search term."
})

agent.add_skill("datetime")

agent.add_skill("datetime")  # Datetime skill works with default settings

agent.add_skill("math")  # No configuration parameters needed

# First create a search index
# sw-search docs/ --output knowledge.swsearch

agent.add_skill("native_vector_search", {
    "index_file": "knowledge.swsearch"
})

agent.add_skill("native_vector_search", {
    "index_file": "knowledge.swsearch",
    "max_results": 10,                   # Maximum search results
    "similarity_threshold": 0.7,         # Minimum similarity score
    "hybrid_search": True,               # Combine vector + keyword
    "boost_keywords": True,              # Boost exact keyword matches
    "search_fields": ["content", "title"], # Fields to search
    "result_format": "detailed"          # How to format results
})

# Skills use configuration parameters passed to add_skill()
# Global configuration can be set via environment variables

# Basic web search with default parameters
agent.add_skill("web_search")

# General search with defaults
agent.add_skill("web_search")

# News-focused search with custom config
agent.add_skill("web_search", {
    "api_key": "your-google-api-key",
    "search_engine_id": "news-search-engine-id",
    "num_results": 5,
    "tool_name": "news_search"
})

# Basic datetime skill
agent.add_skill("datetime")

# Web search with specific parameters
agent.add_skill("web_search", {
    "api_key": "your-google-api-key",
    "search_engine_id": "your-search-engine-id",
    "num_results": 3
})

# Quick search for immediate answers
agent.add_skill("web_search", {
    "api_key": "your-google-api-key",
    "search_engine_id": "quick-search-engine-id",
    "num_results": 1,
    "delay": 0,
    "tool_name": "quick_search"
})

# Research search for detailed information
agent.add_skill("web_search", {
    "api_key": "your-google-api-key",
    "search_engine_id": "research-search-engine-id",
    "num_results": 5,
    "delay": 1.0,
    "tool_name": "research_search"
})

# Another web search instance for news
agent.add_skill("web_search", {
    "api_key": "your-google-api-key",
    "search_engine_id": "news-engine-id", 
    "num_results": 5,
    "tool_name": "news_search"
})

from signalwire_agents.core.skill_base import SkillBase

class DatabaseLookupSkill(SkillBase):
    """Custom skill for database queries"""

    SKILL_NAME = "database_lookup"
    SKILL_DESCRIPTION = "Look up information in the company database"
    SKILL_VERSION = "1.0.0"
    REQUIRED_PACKAGES = []
    REQUIRED_ENV_VARS = []

    def setup(self) -> bool:
        """Setup the skill"""
        return True

    def register_tools(self) -> None:
        """Register database lookup tool"""
        self.agent.define_tool(
            name="lookup_database",
            description="Look up information in the company database",
            parameters={
                "table": {
                    "type": "string",
                    "description": "Database table to query"
                },
                "criteria": {
                    "type": "object", 
                    "description": "Search criteria"
                },
                "limit": {
                    "type": "integer",
                    "description": "Maximum results",
                    "default": 10
                }
            },
            handler=self._database_handler
        )

    def _database_handler(self, args, raw_data):
        """Handle database lookup requests"""
        table = args.get("table")
        criteria = args.get("criteria", {})
        limit = args.get("limit", 10)

        # Your database query logic here
        results = self.query_database(table, criteria, limit)

        from signalwire_agents.core.function_result import SwaigFunctionResult
        return SwaigFunctionResult(f"Found {len(results)} records in {table}")

    def query_database(self, table, criteria, limit):
        # Implement your database query logic
        return []

# Register and use the custom skill
agent.register_skill(DatabaseLookupSkill)
agent.add_skill("database_lookup", {
    "default_table": "customers",
    "connection_string": "your_db_connection"
})

class WeatherAPISkill(Skill):
    """Custom weather skill with API integration"""

    skill_name = "weather_api"
    description = "Get current weather and forecasts using external API"

    parameters = [
        SkillParameter("location", "string", "City or coordinates", required=True),
        SkillParameter("forecast_days", "integer", "Number of forecast days", default=1),
        SkillParameter("include_alerts", "boolean", "Include weather alerts", default=False)
    ]

    def __init__(self, config=None):
        super().__init__(config)
        self.api_key = config.get("api_key") if config else None
        self.units = config.get("units", "metric")
        self.language = config.get("language", "en")

    def execute(self, args, agent):
        if not self.api_key:
            return {"success": False, "error": "API key not configured"}

        location = args["location"]
        forecast_days = args.get("forecast_days", 1)
        include_alerts = args.get("include_alerts", False)

        try:
            weather_data = self.fetch_weather(location, forecast_days, include_alerts)
            return {
                "success": True,
                "data": weather_data,
                "message": f"Weather information for {location}"
            }
        except Exception as e:
            return {"success": False, "error": str(e)}

    def fetch_weather(self, location, forecast_days, include_alerts):
        # Implement API call logic
        pass

# Use with configuration
agent.register_skill(WeatherAPISkill)
agent.add_skill("weather_api", {
    "api_key": "your_api_key",
    "units": "imperial",
    "language": "en"
})

# Good: Clear, specific configuration
agent.add_skill("web_search", {
    "num_results": 3,           # Specific number
    "max_characters": 1000,     # Reasonable limit
    "search_type": "general"    # Clear intent
})

# Better: Environment-based configuration
import os

agent.add_skill("web_search", {
    "num_results": int(os.getenv("SEARCH_RESULTS", 3)),
    "api_key": os.getenv("SEARCH_API_KEY"),
    "rate_limit": int(os.getenv("SEARCH_RATE_LIMIT", 100))
})

# Skills should handle errors gracefully
class RobustCustomSkill(Skill):
    def execute(self, args, agent):
        try:
            # Main logic here
            result = self.process_request(args)
            return {"success": True, "data": result}
        except ValueError as e:
            # Handle specific errors
            return {"success": False, "error": f"Invalid input: {e}"}
        except Exception as e:
            # Handle unexpected errors
            agent.logger.error(f"Skill error: {e}")
            return {"success": False, "error": "An unexpected error occurred"}

# Cache expensive operations
class CachedAPISkill(Skill):
    def __init__(self, config=None):
        super().__init__(config)
        self.cache = {}
        self.cache_ttl = config.get("cache_ttl", 300)  # 5 minutes

    def execute(self, args, agent):
        cache_key = self.generate_cache_key(args)

        # Check cache first
        if cache_key in self.cache:
            cached_result, timestamp = self.cache[cache_key]
            if time.time() - timestamp < self.cache_ttl:
                return cached_result

        # Fetch new data
        result = self.fetch_data(args)

        # Cache result
        self.cache[cache_key] = (result, time.time())

        return result

from signalwire_agents.core.data_map import DataMap
from signalwire_agents.core.function_result import SwaigFunctionResult

# Simple API call example
weather_tool = (DataMap('get_weather')
    .parameter('location', 'string', 'City name', required=True)
    .webhook('GET', 'https://api.weather.com/v1/current?key=API_KEY&q=${args.location}')
    .output(SwaigFunctionResult('Weather in ${args.location}: ${response.current.temp_f}°F'))
)

# Register with agent
agent.register_swaig_function(weather_tool.to_swaig_function())

# Complex API integration with correct configuration
user_lookup_tool = (DataMap('lookup_user')
    .parameter('user_id', 'string', 'User identifier', required=True)
    .parameter('include_history', 'boolean', 'Include order history', required=False)
    .parameter('format', 'string', 'Response format', enum=['summary', 'detailed'], required=False)

    # Main API call with headers defined in webhook
    .webhook('GET', 'https://api.company.com/users/${args.user_id}', 
             headers={
                 'Authorization': 'Bearer YOUR_API_TOKEN',
                 'Content-Type': 'application/json',
                 'X-Include-History': '${args.include_history}'
             })

    # Output with response data
    .output(SwaigFunctionResult("""
        User: ${response.full_name} (ID: ${response.id})
        Status: ${response.account_status}
        Last Login: ${response.last_activity.login_time}
    """))

    # Error handling via error_keys
    .error_keys(['error', 'message', 'status'])
)

# GET request with query parameters in URL
get_tool = (DataMap('search_products')
    .parameter('query', 'string', 'Search term', required=True)
    .parameter('category', 'string', 'Product category', required=False)
    .parameter('limit', 'integer', 'Results limit', required=False)
    .webhook('GET', 'https://api.shop.com/products?q=${args.query}&cat=${args.category}&limit=${args.limit}')
    .output(SwaigFunctionResult('Found products: ${response.count} results'))
)

# POST request with JSON body
create_tool = (DataMap('create_ticket')
    .parameter('title', 'string', 'Ticket title', required=True)
    .parameter('description', 'string', 'Ticket description', required=True)
    .parameter('priority', 'string', 'Priority level', enum=['low', 'medium', 'high'], required=False)
    .webhook('POST', 'https://api.support.com/tickets',
             headers={'Content-Type': 'application/json'})
    .body({
        'title': '${args.title}',
        'description': '${args.description}',
        'priority': '${args.priority}',
        'created_by': 'ai_agent'
    })
    .output(SwaigFunctionResult('Created ticket #${response.id}: ${response.title}'))
)

# PUT request for updates  
update_tool = (DataMap('update_status')
    .parameter('ticket_id', 'string', 'Ticket ID', required=True)
    .parameter('status', 'string', 'New status', enum=['open', 'in_progress', 'resolved'], required=True)
    .webhook('PUT', 'https://api.support.com/tickets/${args.ticket_id}',
             headers={'Authorization': 'Bearer YOUR_API_KEY'})
    .body({'status': '${args.status}', 'updated_by': 'ai_agent'})
    .output(SwaigFunctionResult('Updated ticket ${args.ticket_id} to ${args.status}'))
)

# DELETE request
delete_tool = (DataMap('delete_item')
    .parameter('item_id', 'string', 'Item to delete', required=True)
    .webhook('DELETE', 'https://api.inventory.com/items/${args.item_id}',
             headers={'Authorization': 'API-Key YOUR_API_KEY'})
    .output(SwaigFunctionResult('Item ${args.item_id} deleted successfully'))
)

# Bearer token authentication
auth_tool = (DataMap('secure_action')
    .webhook('GET', 'https://api.secure.com/data', 
             headers={'Authorization': 'Bearer YOUR_AUTH_TOKEN'})
)

# API key in header  
api_key_tool = (DataMap('api_call')
    .webhook('GET', 'https://api.service.com/endpoint',
             headers={
                 'X-API-Key': 'YOUR_API_KEY',
                 'X-Client-ID': 'YOUR_CLIENT_ID'
             })
)

# Basic authentication (you would need to base64 encode credentials beforehand)
basic_auth_tool = (DataMap('basic_auth_call')
    .webhook('GET', 'https://api.legacy.com/data',
             headers={'Authorization': 'Basic YOUR_ENCODED_CREDENTIALS'})
)

# OAuth2 token
oauth_tool = (DataMap('oauth_call') 
    .webhook('GET', 'https://api.oauth.com/data',
             headers={'Authorization': 'Bearer YOUR_OAUTH_TOKEN'})
)

# Function arguments
.webhook('GET', 'https://api.example.com/users/${args.user_id}')

# Authentication headers
.header('Authorization', 'Bearer YOUR_API_TOKEN')

# Response data from API calls
.output(SwaigFunctionResult('Status: ${response.status}, Message: ${response.data.message}'))

# Static values and response variables
.body({'created_by': 'agent', 'api_version': '1.0'})

# Access nested response data
.output(SwaigFunctionResult('Status: ${response.status}, Message: ${response.data.message}'))

# Use response arrays (with foreach processing)
.foreach('${response.results}')
.output(SwaigFunctionResult('Found: ${foreach.title} - ${foreach.summary}'))

# Static values and simple variable substitution
'2024-01-01T00:00:00Z'                     # Static timestamp values
'${response.created_at}'                   # Response fields
'${args.user_id}'                          # Function arguments

# Basic API integration that actually works
pricing_tool = (DataMap('get_product_price')
    .parameter('product_id', 'string', 'Product ID', required=True)
    .webhook('GET', 'https://api.example.com/products/${args.product_id}', 
             headers={'Authorization': 'Bearer YOUR_API_TOKEN'})
    .output(SwaigFunctionResult("""
        Product: ${response.name}
        Price: $${response.price}
        In Stock: ${response.in_stock}
    """))
    .error_keys(['error', 'message'])
)

### Error Handling

```python
# Simple error handling with error_keys
robust_tool = (DataMap('robust_api_call')
    .parameter('id', 'string', 'Resource ID', required=True)

    # Main API call
    .webhook('GET', 'https://api.service.com/resource/${args.id}')

    # Handle standard response
    .output(SwaigFunctionResult('Successfully retrieved: ${response.name} (Status: ${response.status})'))
)

# Simple, working DataMap tool
basic_tool = (DataMap('lookup_user')
    .parameter('user_id', 'string', 'User ID', required=True)
    .webhook('GET', 'https://api.users.com/users/${args.user_id}')
    .header('Accept', 'application/json')
    .output(SwaigFunctionResult('${response.name} (${response.email})'))
)

# Use DataMap for API calls, Skills for common operations
agent.add_skill("datetime")  # Built-in datetime functionality
agent.add_skill("web_search")  # Built-in web search

# DataMap for business-specific API
customer_tool = (DataMap('get_customer')
    .parameter('customer_id', 'string', 'Customer ID', required=True)
    .webhook('GET', 'https://api.crm.com/customers/${customer_id}')
    .output(SwaigFunctionResult('Customer: ${response.name}, Status: ${response.status}'))
)
agent.register_swaig_function(customer_tool.to_swaig_function())

# Custom SWAIG function for complex logic
@agent.swaig_function
def process_order(args):
    # Complex multi-step business logic
    customer = get_customer_from_db(args['customer_id'])
    inventory = check_inventory(args['items'])
    pricing = calculate_complex_pricing(customer, args['items'])
    # ... more complex logic
    return create_order(customer, inventory, pricing)

# Install SDK with search capabilities
pip install "signalwire-agents[search]"

sw-search --help

# Index all documents in a directory
sw-search docs/ --output knowledge.swsearch

# Index with specific file types
sw-search docs/ --include "*.md,*.txt,*.pdf" --output knowledge.swsearch

# Index with custom settings
sw-search docs/ --output knowledge.swsearch --chunk-size 500 --overlap 50

# Comprehensive indexing with all options
sw-search docs/ \
    --output knowledge.swsearch \
    --include "*.md,*.txt,*.pdf,*.docx" \
    --exclude "*.tmp,*~" \
    --chunk-size 1000 \
    --overlap 100 \
    --model "all-MiniLM-L6-v2" \
    --batch-size 32 \
    --verbose

# Text-based formats
sw-search docs/ --include "*.txt,*.md,*.rst,*.log"

# Office documents
sw-search docs/ --include "*.docx,*.xlsx,*.pptx"

# PDFs and web formats
sw-search docs/ --include "*.pdf,*.html,*.xml"

# Mixed content
sw-search docs/ --include "*.md,*.pdf,*.docx,*.txt"

from signalwire_agents.cli.search import IndexBuilder

# Create index builder - Note: This is currently CLI-only functionality
# For programmatic use, use the sw-search command line tool
# Example: sw-search docs/ --output knowledge.swsearch

from signalwire_agents import AgentBase

agent = AgentBase("Knowledge Assistant")
agent.set_prompt_text("I help answer questions using our knowledge base and can search the web for additional information.")

# Add search capability
agent.add_skill("native_vector_search", {
    "index_file": "knowledge.swsearch"
})

# Also add web search for external information
agent.add_skill("web_search", {
    "num_results": 3
})

if __name__ == "__main__":
    agent.run()

# Comprehensive search configuration
agent.add_skill("native_vector_search", {
    "index_file": "knowledge.swsearch",
    "count": 10,                          # Maximum search results
    "distance_threshold": 0.7,            # Minimum similarity score (0.0-1.0)
    "tool_name": "search_knowledge",      # Custom tool name
    "description": "Search the knowledge base",  # Tool description
    "no_results_message": "No information found for '{query}'",  # Custom no results message
    "response_prefix": "",                # Text to add before results
    "response_postfix": "",               # Text to add after results
    "tags": []                            # Filter by tags
})

# General company knowledge
agent.add_skill("native_vector_search", {
    "index_file": "general_knowledge.swsearch",
    "count": 5,
    "tool_name": "search_general"
})

# Technical documentation
agent.add_skill("native_vector_search", {
    "index_file": "tech_docs.swsearch",
    "distance_threshold": 0.8,
    "count": 3,
    "tool_name": "search_technical"
})

# FAQ and support content
agent.add_skill("native_vector_search", {
    "index_file": "support_faq.swsearch",
    "count": 5,
    "tool_name": "search_support"
})

# Check index information
sw-search-info knowledge.swsearch

# Merge multiple indexes
sw-search-merge index1.swsearch index2.swsearch --output combined.swsearch

# Update existing index with new documents
sw-search-update knowledge.swsearch --add-dir new_docs/

# Validate index integrity
sw-search-validate knowledge.swsearch

# Export index contents
sw-search-export knowledge.swsearch --format json --output knowledge.json

# Test search queries
sw-search-query knowledge.swsearch "How do I reset my password?"

# Test with specific parameters
sw-search-query knowledge.swsearch "API documentation" \
    --max-results 5 \
    --similarity-threshold 0.7 \
    --hybrid-search

# Batch testing with query file
sw-search-batch knowledge.swsearch --queries queries.txt --output results.json

# Optimize index for faster searches
sw-search-optimize knowledge.swsearch

# Rebuild index with better settings
sw-search docs/ --output knowledge_v2.swsearch \
    --chunk-size 800 \
    --overlap 150 \
    --model "all-mpnet-base-v2" \
    --optimize-for speed

# Create compressed index for deployment
sw-search-compress knowledge.swsearch --output knowledge_compressed.swsearch

# High-quality model for general content
sw-search docs/ --model "all-mpnet-base-v2" --output general.swsearch

# Multilingual model for international content
sw-search docs/ --model "paraphrase-multilingual-MiniLM-L12-v2" --output multilingual.swsearch

# Domain-specific model for technical content
sw-search technical_docs/ --model "sentence-transformers/allenai-specter" --output technical.swsearch

from signalwire_agents.search import IndexBuilder

builder = IndexBuilder()

# Add documents with metadata
builder.add_file("user_guide.pdf", metadata={
    "category": "documentation",
    "audience": "end_user",
    "version": "2.1",
    "language": "en"
})

builder.add_file("api_reference.md", metadata={
    "category": "technical",
    "audience": "developer",
    "version": "2.1",
    "language": "en"
})

# Build index with metadata support
builder.build_index("categorized.swsearch")

agent.add_skill("native_vector_search", {
    "index_file": "categorized.swsearch",
    "filter_metadata": {
        "category": "documentation",
        "audience": "end_user"
    }
})

from signalwire_agents.search import IndexWatcher
import asyncio

async def maintain_search_index():
    """Keep search index updated automatically"""
    watcher = IndexWatcher(
        watch_directory="docs/",
        index_file="knowledge.swsearch",
        update_interval=300  # Check every 5 minutes
    )

    await watcher.start()

# Run in background
asyncio.create_task(maintain_search_index())

from signalwire_agents.search import SearchAnalytics

# Enable search analytics
agent.add_skill("native_vector_search", {
    "index_file": "knowledge.swsearch",
    "enable_analytics": True,
    "analytics_file": "search_analytics.json"
})

# Analyze search patterns
analytics = SearchAnalytics.load("search_analytics.json")
print(f"Top queries: {analytics.top_queries(10)}")
print(f"Low-relevance queries: {analytics.low_relevance_queries()}")
print(f"Search success rate: {analytics.success_rate():.2%}")

# Organize by content type
sw-search user_docs/ --output user_knowledge.swsearch
sw-search technical_docs/ --output tech_knowledge.swsearch
sw-search faq/ --output faq_knowledge.swsearch

# Organize by update frequency
sw-search static_content/ --output static.swsearch
sw-search dynamic_content/ --output dynamic.swsearch --watch

# Password Reset Procedure
*Category: User Support | Audience: End Users | Last Updated: 2024-01-15*

## Overview
This guide explains how to reset your password when you've forgotten it or need to change it for security reasons.

## Step-by-Step Instructions
1. Navigate to the login page
2. Click "Forgot Password?"
3. Enter your email address
4. Check your email for reset instructions
5. Follow the link in the email
6. Create a new secure password

## Troubleshooting
If you don't receive the reset email:
- Check your spam folder
- Verify you're using the correct email address
- Contact support if issues persist

## Related Topics
- Account Security Best Practices
- Two-Factor Authentication Setup
- Password Requirements

# Optimize for search speed vs. accuracy
fast_config = {
    "chunk_size": 500,           # Smaller chunks for faster processing
    "similarity_threshold": 0.8, # Higher threshold for fewer results
    "max_results": 3,            # Limit result count
    "hybrid_search": False       # Vector-only for speed
}

# Optimize for search accuracy
accurate_config = {
    "chunk_size": 1200,          # Larger chunks for more context
    "similarity_threshold": 0.6, # Lower threshold for more results
    "max_results": 10,           # More comprehensive results
    "hybrid_search": True,       # Best of both search types
    "rerank_results": True       # Re-rank for optimal ordering
}

# Secure deployment configuration
secure_agent = Agent(
    assistant=Assistant(
        name="Secure Knowledge Assistant",
        purpose="I provide information from our secure knowledge base."
    )
)

# Add search with access controls
secure_agent.add_skill("native_vector_search", {
    "index_file": "secure_knowledge.swsearch",
    "access_control": True,
    "allowed_categories": ["public", "internal"],  # Filter by user access level
    "redact_sensitive": True,    # Automatically redact sensitive information
    "audit_searches": True       # Log all search queries for compliance
})

# Main sections with body text
self.prompt_add_section("Personality", 
                       body="You are a customer service representative for SignalWire.")

# Sections with bullet points
self.prompt_add_section("Instructions", bullets=[
    "Always ask for account verification before sharing sensitive information",
    "Offer to escalate to a human if you cannot resolve the issue",
    "Maintain a professional but friendly tone"
])

# Sections with both body and bullets
self.prompt_add_section("Context", 
                       body="The user is calling about a technical issue.",
                       bullets=["They may be experiencing service disruption", 
                               "Have technical account details ready"])

# Numbered sections
self.prompt_add_section("Process", 
                       bullets=["Verify identity", "Diagnose problem", "Suggest solution"],
                       numbered=True)  # Creates a numbered list

# Add subsections for better organization
self.prompt_add_subsection("Instructions", "Technical Support", bullets=[
    "Ask for error messages",
    "Check service status before troubleshooting"
])

# Add to an existing section 
self.prompt_add_to_section("Context", 
                          bullet="Current system status: All services operational")

# Add or update sections based on runtime conditions
if high_call_volume:
    self.prompt_add_section("Priority", 
                          body="Focus on quick resolution due to high call volume")
else:
    self.prompt_add_section("Priority", 
                          body="Take time to fully address customer needs")

# These are equivalent to prompt_add_section with appropriate titles
self.setPersonality("You are a technical support specialist.")
self.setGoal("Resolve customer technical issues efficiently.")
self.setInstructions([
    "Get specific error details",
    "Guide users through troubleshooting steps",
    "Document the resolution"
])

# Add English as the primary language
self.add_language(
    name="English",
    code="en-US",
    voice="elevenlabs.josh",  # Using ElevenLabs voice
    speech_fillers=["Let me think about that...", "One moment please..."],
    function_fillers=["I'm looking that up for you...", "Let me check that..."]
)

# Add Spanish with appropriate fillers
self.add_language(
    name="Spanish",
    code="es",
    voice="elevenlabs.antonio:eleven_multilingual_v2",
    speech_fillers=["Un momento por favor...", "Estoy pensando..."],
    function_fillers=["Estoy buscando esa información...", "Déjame verificar..."]
)

# Add French with specific engine and model parameters
self.add_language(
    name="French",
    code="fr-FR",
    voice="rime.alois",
    speech_fillers=["Un instant s'il vous plaît...", "Laissez-moi réfléchir..."]
)

# Enable language detection and switching
self.set_params({"languages_enabled": True})

# Simple format
voice="en-US-Neural2-F"

# Provider-prefixed format
voice="elevenlabs.josh"

# Provider with model
voice="elevenlabs.antonio:eleven_multilingual_v2"

# Explicit parameters
self.add_language(
    name="German",
    code="de-DE",
    voice="hans",
    engine="rime",
    model="arcana"
)

# Spell out acronyms
self.add_pronunciation("API", "A P I", ignore_case=False)
self.add_pronunciation("SDK", "S D K", ignore_case=True)

# Correct pronunciation of brand names
self.add_pronunciation("SignalWire", "Signal Wire", ignore_case=False)
self.add_pronunciation("PostgreSQL", "Postgres Q L", ignore_case=True)

# Help with AI terms using regex patterns
self.add_pattern_hint(
    hint="AI Agent",
    pattern="AI\\s+Agent",
    replace="A.I. Agent",
    ignore_case=True
)

# Format version numbers appropriately
self.add_pattern_hint(
    hint="version numbers",
    pattern="v(\\d+)\\.(\\d+)",
    replace="version $1 point $2",
    ignore_case=True
)

# Add product and technical terms as hints
self.add_hints([
    "SignalWire",
    "SWML",
    "SWAIG",
    "WebRTC",
    "SIP"
])

# Configure AI behavior parameters
self.set_params({
    # Conversation flow
    "wait_for_user": False,          # Start speaking immediately vs. waiting for user
    "end_of_speech_timeout": 1000,   # Milliseconds of silence to detect end of speech
    "energy_level": 50,              # Sensitivity for detecting speech (0-100)

    # Voice and audio settings
    "ai_volume": 5,                  # Voice volume level
    "background_file": "https://example.com/hold-music.mp3",  # Background audio
    "background_file_volume": -10,   # Volume for background audio

    # Interruption handling
    "transparent_barge": True,       # Allow users to interrupt the AI
    "barge_min_words": 3,            # Min words needed to trigger interruption

    # Timeout handling
    "attention_timeout": 30000,      # Milliseconds before prompting unresponsive user
    "inactivity_timeout": 300000,    # Milliseconds of inactivity before ending session

    # Language settings
    "languages_enabled": True,       # Enable multilingual support
    "local_tz": "America/New_York",  # Default timezone for time functions

    # Advanced features
    "enable_vision": False,          # Enable visual processing capabilities
    "verbose_logs": True             # Enable detailed logging
})

# Update a single parameter
self.set_param("ai_volume", 7)

from signalwire_agents import AgentBase

# This agent is stateless by default
agent = Agent(
    assistant=Assistant(
        name="Stateless Assistant",
        purpose="I help users without maintaining persistent state."
    )
)

# Each conversation is independent
# No state is carried between conversations
# Perfect for high-scale, concurrent usage

@agent.swaig_function
def save_user_preference(args):
    preference_type = args.get("preference_type")
    preference_value = args.get("preference_value")

    # Get current global data (available to AI)
    current_data = agent.get_global_data()

    # Update with user preference
    current_data["user_preferences"] = current_data.get("user_preferences", {})
    current_data["user_preferences"][preference_type] = preference_value

    # Set updated global data - now available to AI in conversation
    agent.set_global_data(current_data)

    return SwaigFunctionResult(f"I've saved your {preference_type} preference as {preference_value}.")

# The AI will now know about user preferences in its responses
# Global data is automatically included in the AI's context

@agent.swaig_function
def create_support_ticket(args):
    issue_description = args.get("issue_description")
    priority = args.get("priority", "medium")

    # Create ticket in your system
    ticket_id = create_ticket_in_system(issue_description, priority)

    # Return result with metadata for future reference
    return SwaigFunctionResult(
        f"I've created support ticket #{ticket_id} for your issue.",
        meta_data={
            "ticket_id": ticket_id,
            "priority": priority,
            "created_at": datetime.now().isoformat(),
            "issue_type": "general_support"
        }
    )

@agent.swaig_function
def start_order_process(args):
    # Initialize order in global data
    agent.set_global_data({
        "current_order": {
        "status": "collecting_items",
        "items": [],
            "total": 0.0,
            "customer_info": None
        }
    })

    return SwaigFunctionResult("I've started a new order for you. What would you like to add?")

@agent.swaig_function
def add_item_to_order(args):
    item_name = args.get("item_name")
    quantity = args.get("quantity", 1)
    price = args.get("price")

    # Get current order from global data
    global_data = agent.get_global_data()
    current_order = global_data.get("current_order", {})

    # Add item to order
    current_order["items"].append({
        "name": item_name,
        "quantity": quantity,
        "price": price
    })
    current_order["total"] += price * quantity

    # Update global data
    global_data["current_order"] = current_order
    agent.set_global_data(global_data)

    return SwaigFunctionResult(
        f"Added {quantity}x {item_name} to your order. Current total: ${current_order['total']:.2f}"
    )

@agent.swaig_function
def complete_order(args):
    global_data = agent.get_global_data()
    order = global_data.get("current_order", {})

    if not order.get("items"):
        return SwaigFunctionResult("No items in your order. Please add items first.")

    # Process the order
    order_id = process_order_in_system(order)

    # Clear the order from global data
    global_data.pop("current_order", None)
    agent.set_global_data(global_data)

    return SwaigFunctionResult(
        f"Order #{order_id} has been placed successfully! Total: ${order['total']:.2f}",
        meta_data={
            "order_id": order_id,
            "total_amount": order["total"],
            "item_count": len(order["items"])
        }
    )

@agent.swaig_function
def get_user_profile(args):
    user_id = args.get("user_id")

    # Query external database/service
    user_profile = external_database.get_user(user_id)

    # Store relevant info in global_data for AI access
    agent.set_global_data({
        "current_user": {
            "name": user_profile["name"],
            "tier": user_profile["tier"],
            "preferences": user_profile["preferences"]
        }
    })

    return SwaigFunctionResult(f"Hello {user_profile['name']}! I've loaded your profile.")

@AgentBase.tool(
    name="book_appointment",
    description="Book an appointment for a customer",
    parameters={
        "customer_name": {
            "type": "string",
            "description": "The full name of the customer"
        },
        "service_type": {
            "type": "string",
            "description": "The type of service requested",
            "enum": ["haircut", "coloring", "styling", "consultation"]
        },
        "preferred_date": {
            "type": "string",
            "description": "The preferred date for the appointment (YYYY-MM-DD)"
        },
        "preferred_time": {
            "type": "string",
            "description": "The preferred time for the appointment (HH:MM)",
            "pattern": "^([0-1]?[0-9]|2[0-3]):[0-5][0-9]$"
        },
        "special_requests": {
            "type": "string",
            "description": "Any special requests or notes",
            "nullable": True
        }
    }
)

@AgentBase.tool(
    name="check_order_status",
    description="Check the status of a customer's order",
    parameters={
        "order_id": {
            "type": "string",
            "description": "The order ID to check"
        }
    }
)
def check_order_status(self, args, raw_data):
    """
    Check the status of an order in our system.

    Args:
        args: Dictionary containing the parsed parameters (order_id)
        raw_data: Complete request data including call_id and other metadata

    Returns:
        SwaigFunctionResult with the order status information
    """
    # Extract the order ID from args
    order_id = args.get("order_id")

    # Log the function call
    self.log.info("check_order_status_called", order_id=order_id)

    try:
        # In a real implementation, you would query your order system
        # For this example, we'll simulate different statuses

        # Simulate a database query
        # order_data = order_database.get_order(order_id)

        # For demonstration, generate a status based on the order ID
        status_options = ["processing", "shipped", "delivered", "pending"]
        simulated_status = status_options[hash(order_id) % len(status_options)]

        # Create estimated delivery date (for demonstration)
        from datetime import datetime, timedelta
        estimated_delivery = (datetime.now() + timedelta(days=3)).strftime("%Y-%m-%d")

        # Format response based on status
        if simulated_status == "processing":
            response = f"Order {order_id} is currently being processed. Estimated shipping in 1-2 business days."
        elif simulated_status == "shipped":
            response = f"Order {order_id} has been shipped and is on its way. Expected delivery by {estimated_delivery}."
        elif simulated_status == "delivered":
            response = f"Order {order_id} has been delivered. It was completed on {estimated_delivery}."
        else:  # pending
            response = f"Order {order_id} is pending payment confirmation. Please allow 24 hours for processing."

        # Create the result
        result = SwaigFunctionResult(response)

        # Add the order status to global data for future reference
        result.add_action("set_global_data", {
            "last_checked_order": {
                "id": order_id,
                "status": simulated_status,
                "estimated_delivery": estimated_delivery
            }
        })

        return result

    except Exception as e:
        # Handle errors gracefully
        self.log.error("order_status_error", error=str(e), order_id=order_id)
        return SwaigFunctionResult(
            f"I'm sorry, I couldn't retrieve information for order {order_id}. " +
            "Please verify the order number or try again later."
        )

@AgentBase.tool(
    name="process_payment",
    description="Process a payment for an order",
    parameters={
        "amount": {
            "type": "number",
            "description": "Payment amount"
        },
        "payment_method": {
            "type": "string",
            "description": "Payment method (credit_card, bank_transfer)",
            "enum": ["credit_card", "bank_transfer"]
        }
    }
)
def process_payment(self, args, raw_data):
    amount = args.get("amount")
    payment_method = args.get("payment_method")

    # Simulate payment processing
    transaction_id = f"TXN-{hash(str(amount) + payment_method) % 10000:04d}"

    # Create the result with an initial response
    result = SwaigFunctionResult(
        f"I've processed your {payment_method} payment for ${amount:.2f}. " +
        f"Your transaction ID is {transaction_id}."
    )

    # Add a single action
    result.add_action("log", {
        "message": f"Payment processed: ${amount:.2f} via {payment_method}"
    })

    # Add multiple actions at once
    result.add_actions([
        # Update global data with payment info
        {"set_global_data": {
            "last_transaction": {
                "id": transaction_id,
                "amount": amount,
                "method": payment_method,
                "status": "completed"
            }
        }},
        # Play a success sound in the background
        {"playback_bg": {
            "file": "https://example.com/sounds/payment_success.mp3",
            "wait": False
        }}
    ])

    # Chain actions for readability (alternative to add_actions)
    result.add_action("say", "Your receipt will be emailed to you shortly.")

    return result

# Register native functions
self.set_native_functions([
    "check_time",       # Get the current time in various formats/timezones
    "wait_seconds"      # Pause the conversation for a specified duration
])

# Include functions from an external API
self.add_function_include(
    url="https://api.example.com/ai-functions",
    functions=[
        "search_knowledge_base",
        "get_product_details",
        "calculate_shipping"
    ],
    meta_data={
        "api_key": "your-api-key",
        "organization_id": "org123"
    }
)

# Include another set of functions from a different API
self.add_function_include(
    url="https://analytics.example.org/functions",
    functions=["get_user_insights"]
)

@AgentBase.tool(
    name="get_account_details",
    description="Get customer account details",
    parameters={"account_id": {"type": "string"}},
    secure=True  # This is the default
)

@AgentBase.tool(
    name="search_database",
    description="Search the customer database",
    parameters={"query": {"type": "string"}},
    fillers={
        "en-US": [
            "Let me search our records...",
            "I'm looking that up for you...",
            "Checking our database..."
        ],
        "es": [
            "Déjame buscar en nuestros registros...",
            "Estoy buscando esa información..."
        ]
    }
)

from signalwire_agents.prefabs import InfoGathererAgent

# Create an agent that collects user registration information
registration_agent = InfoGathererAgent(
    name="registration-form",
    route="/register",
    questions=[
        {
            "key_name": "full_name",
            "question_text": "What is your full name?"
        },
        {
            "key_name": "email",
            "question_text": "What is your email address?",
            "confirm": True  # This will prompt the AI to confirm the answer
        },
        {
            "key_name": "birth_date",
            "question_text": "What is your date of birth? Please provide it in MM/DD/YYYY format."
        },
        {
            "key_name": "reason",
            "question_text": "What brings you to our service today?"
        }
    ]
)

class CustomInfoGatherer(InfoGathererAgent):
    def __init__(self):
        super().__init__(
            name="customer-intake",
            route="/intake",
            questions=[
                {"key_name": "name", "question_text": "What is your name?"},
                {"key_name": "issue", "question_text": "Please describe your issue briefly."}
            ]
        )
        # Add a custom prompt section for more personalized interactions
        self.prompt_add_section("Introduction", 
                               body="Greet the user warmly and explain that you'll need to collect some information to help them.")

    # Override to add custom processing after all questions are answered
    def on_all_questions_completed(self, call_id, answers):
        # Process the collected information
        print(f"All questions completed for call {call_id}")
        print(f"Answers: {answers}")

        # You could add automatic routing, ticket creation, etc. here

        # Return a custom message
        return "Thank you for providing that information. I've created a support ticket for you, and a specialist will contact you shortly."

    # Add a custom function for after information is collected
    @AgentBase.tool(
        name="schedule_follow_up",
        description="Schedule a follow-up call",
        parameters={
            "preferred_time": {"type": "string", "description": "Preferred time for follow-up"}
        }
    )
    def schedule_follow_up(self, args, raw_data):
        # Implementation details...
        return SwaigFunctionResult("Your follow-up has been scheduled.")

from signalwire_agents.prefabs import FAQBotAgent

# Create an agent with direct FAQ content
support_agent = FAQBotAgent(
    name="product-support",
    route="/support",
    faq_content=[
        {
            "question": "How do I reset my password?",
            "answer": "To reset your password, visit the login page and click on 'Forgot Password'. Follow the instructions sent to your email."
        },
        {
            "question": "What payment methods do you accept?",
            "answer": "We accept Visa, Mastercard, American Express, and PayPal."
        },
        {
            "question": "How long does shipping take?",
            "answer": "Standard shipping typically takes 3-5 business days within the continental US."
        }
    ]
)

# Alternatively, load from a file
documentation_agent = FAQBotAgent(
    name="api-docs",
    route="/docs",
    faq_file="documentation.json"  # JSON file with question/answer pairs
)

# Or load from a URL
knowledge_agent = FAQBotAgent(
    name="knowledge-base",
    route="/kb",
    faq_url="https://example.com/api/knowledge-base",
    refresh_interval=3600  # Refresh content every hour
)

# Create a more customized FAQ bot
advanced_faq_agent = FAQBotAgent(
    name="technical-support",
    route="/tech-support",
    faq_content=tech_support_faqs,

    # Customize how to handle out-of-scope questions
    unknown_question_response="I specialize in technical support for our product line. That question seems outside my area of expertise. Would you like me to connect you with general customer service?",

    # Configure escalation options
    escalation_prompt="I can connect you with a human specialist if you'd prefer. Would you like me to transfer you now?",

    # Add additional context
    system_information={
        "product_versions": ["v1.2.3", "v1.3.0", "v2.0.1"],
        "known_issues": ["Bluetooth connectivity on v1.2.3", "Sleep mode on v2.0.1"]
    }
)