> ## Documentation Index > Fetch the complete documentation index at: https://extended-openai-conversation.mintlify.site/llms.txt > Use this file to discover all available pages before exploring further. # Functions Overview > Learn about function types and how to extend AI capabilities Functions are the core mechanism for extending your AI assistant's capabilities. Each function defines what the AI can do and how it executes actions. ## Function Structure Every function consists of two parts: ```yaml Function Definition theme={null} - spec: name: function_name description: What this function does parameters: type: object properties: param_name: type: string description: Parameter description function: type: function_type # Type-specific configuration ``` ### Specification (spec) The `spec` follows OpenAI's [function schema](https://platform.openai.com/docs/guides/function-calling#defining-functions) format: * **name**: Function identifier (used by AI to call the function) * **description**: Clear explanation of what the function does * **parameters**: JSON schema defining expected parameters Write clear, detailed descriptions. The AI uses these to decide when and how to call functions. ### Function Implementation The `function` section defines how to execute the function: * **type**: Function type (see below) * Additional configuration specific to the function type ## Function Types Built-in functions provided by the component Return dynamic values using Jinja2 templates Execute sequences of Home Assistant services Fetch data from external REST APIs Extract data from web pages Chain multiple function types together Query Home Assistant's database Execute shell commands with security controls Read file contents safely with path restrictions Write content to files safely with path restrictions Safely edit files with find-and-replace operations ## Reserved Parameters ### Delay Parameter Add a delay to execute functions in the background after a specified time: ```yaml theme={null} spec: name: delayed_action description: Execute action after a delay parameters: type: object properties: # Your regular parameters here delay: type: object description: Time to wait before execution properties: hours: type: integer minimum: 0 minutes: type: integer minimum: 0 seconds: type: integer minimum: 0 ``` ## Default Functions Extended OpenAI Conversation includes this default function: ```yaml theme={null} - spec: name: execute_services description: Use this function to execute service of devices in Home Assistant. parameters: type: object properties: list: type: array items: type: object properties: domain: type: string description: The domain of the service service: type: string description: The service to be called service_data: type: object description: The service data object to indicate what to control. properties: entity_id: type: string description: The entity_id retrieved from available devices. required: - entity_id required: - domain - service - service_data function: type: native name: execute_service ``` This function allows the AI to control any exposed Home Assistant entity. ## Adding Custom Functions Add functions through the Options configuration: Navigate to Settings > Voice Assistants > Edit Assistant > Options Scroll to the "Functions" field Paste your function definition in YAML format Click "Submit" to apply changes ## Best Practices Write detailed descriptions that explain exactly what the function does and when to use it. The AI relies on these descriptions to choose the right function. ✅ Good: "Get the current weather and forecast for a specific location using the weather entity" ❌ Bad: "Get weather" Define all required parameters with clear descriptions and appropriate types. ```yaml theme={null} properties: entity_id: type: string description: The entity_id retrieved from available devices. Must start with domain, followed by dot character. ``` Test each function with various inputs before deploying to production. Check edge cases and error handling. Choose the simplest function type that meets your needs. Don't use composite functions when a template would suffice. ## Next Steps Built-in functions Dynamic templates Service sequences