Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.enneo.ai/llms.txt

Use this file to discover all available pages before exploring further.

Enneo allows the depositing of custom code in the form of “User Defined Functions” for various applications. These functions can be particularly used in the business logic of rule-based AI agents, in webhooks or event implementations. Therefore, whenever own code or SDKs are used.

​
Management of User Defined Functions

User defined functions are managed in the Integration of peripheral systems section in the settings. Any number of custom functions can be stored here.
Functions are stored as code fragments that implement specific application logic and are retrievable in various integration scenarios.

​
Application possibilities

User Defined Functions offer various application possibilities. For example:
  • Interfaces calls of the peripheral systems: For instance, ERP, Task-Management, or Archive-Systems.
  • Connection to Output-Management-Systems: For example, for the dispatch of notifications.
  • Outsourcing of complex processes: In the form of reusable building blocks.
With these functionalities, Enneo extends the adaptability and enables the integration of specific company logic into AI-based customer support.

​
Calling User Defined Functions

Enneo can save and use user-defined functions. The following calls are possible, using the example of a User-Defined-Function named ‘my-udf’: Within Enneo using Python SDK: 
sdk.ApiEnneo.executeUdf('my-udf', {"parameter1": "value1", "parameter2": "value2"}, 'serviceWorker')
Within Enneo using PHP SDK: 
\EnneoSDK\ApiEnneo::executeUdf('my-udf', ['parameter1' => 'value1', 'parameter2' => 'value2'],'serviceWorker');
External Web-Request: 
    POST https://your-subdomain.enneo.ai/api/mind/executor/execute/my-udf
    Payload: '{"parameter1": "value1", "parameter2": "value2"}'

​
Storage object for User Defined Functions

Any JSON object can be used as an internal Enneo storage object for custom functions. This allows data to be stored and retrieved using the Enneo-SDK. 
\EnneoSDK\Setting::set('udfStorage', ['my' => 'data']);
$storedData = \EnneoSDK\Setting::get('udfStorage');

​
Example: Calling a Third-Party API

First, required data is set in the storage object for user-defined functions: 
{
  "thirdParty": {
    "oauth": {
      "clientId": "123456789",
      "grantType": "client_credentials",
      "clientSecret": "abcdefg.....hijklmnop",
      "tokenEndpoint": "https://token-url/oauth2/token",
      "baseUrl": "https://third-party-url/api"
    }
  }
}
In the second step, a user-defined function fetch-thirdparty-token can be implemented for loading the credentials. This approach is particularly useful when the loading of credentials can be reused in several other processes. 
<?php

// Load Enneo SDK
require(getenv()['SDK']);

// Load the storage object for user-defined functions
$udfStorage = \EnneoSDK\Setting::get('udfStorage');


// Load Token
$clientId = $udfStorage->thirdParty->oauth->clientId;
$clientSecret = $udfStorage->thirdParty->oauth->clientSecret;

$result = \EnneoSDK\Api::call(
    method: 'POST',
    url: $udfStorage->thirdParty->oauth->tokenEndpoint,
    headers: [
        'Authorization: Basic ' . base64_encode($clientId . ':' . $clientSecret),
        'Content-Type: application/x-www-form-urlencoded',
        'Accept: application/json'
    ],
    params: http_build_query(['grant_type' => $udfStorage->thirdParty->oauth->grantType ?? 'client_credentials',
        'scope' => $udfStorage->thirdParty->oauth->scope ?? null])
);

// The output is in JSON format and can be used after the call in the corresponding code
echo json_encode(['accessToken' => $result->access_token,
    'accessTokenExpiresAt' => date("Y-m-d H:i:s T", time() + $result->expires_in),
    "baseUrl" => $udfStorage->thirdParty->baseUrl,
    "headers" => $udfStorage->thirdParty->headers ?? [],
    "apiName" => $udfStorage->thirdParty->apiName ?? "Customer-API",
]);
Subsequently, the implementation of the function third-party-api-call can take place for the actual API call: 
<?php
<?php

// load SDK
require(getenv()['SDK']);

// Load token using the previously defined "fetch-thirdparty-token" function
$credentials = \EnneoSDK\ApiEnneo::executeUdf('fetch-thirdparty-token', []);

// Load input parameters
$in = \EnneoSDK\Input::load();

// Prepare headers for the third-party API request
$headers = [
    'Authorization: Bearer '. $credentials->accessToken,
    'Accept: application/json'
];
foreach (($cred->headers ?? []) as $key => $val) {
    $headers[] = "$key: $val";
}

// API call and output
$res = \EnneoSDK\Api::call(
    method: $in->method,
    url: $credentials->baseUrl.'/'.$in->api,
    headers: $headers,
    params: $in->params
);

// Output result
echo json_encode($res);
This structure enables flexible use and integration of custom code within Enneo, to map specific business logic or seamlessly connect external systems.

​
Invocation of Custom Functions

The invocation of custom functions in the code is done using executeUdf: 
<?php

// Load Enneo SDK
require(getenv()['SDK']);

// Prepare payload for the API call of the third-party system
$payload = [
    'ticket-id' => 123,
    'key' => 'value'
];

// Invocation of the custom function "third-party-api-call"
// this function receives as input parameter an object:
// [
//      'method' => 'POST',
//      'api' => 'item',
//      'params' => [
//          'ticket-id' => 123,
//           'key' => 'value'
//      ]
// ]
EnneoSDK\ApiEnneo::executeUdf(
    'third-party-api-call',
    ['method' => 'POST', 'api' => 'item', 'params' => $payload]
);