> ## Documentation Index
> Fetch the complete documentation index at: https://launchdarkly-preview.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Customizing AI Configs

> This topic explains how to customize an AI Config. This feature is available for AI SDKs only.

> For the complete documentation index, see [llms.txt](/llms.txt). For the full documentation snapshot, see [llms-full.txt](/llms-full.txt).

## Overview

This topic explains how to customize an AI Config using LaunchDarkly AI SDKs.

Customizing an AI Config evaluates the configuration for a given context and returns the appropriate variation based on targeting rules. Customization requires an AI Config key, a context, a fallback value, and optional variables for substitution.

In completion mode, the customized variation includes the model configuration and messages for the context. In agent mode, the customized variation includes the instructions for the context. In both cases, you must customize the AI Config each time you generate content from your AI model.

## Customize messages

Customizing an AI Config substitutes context attributes and optional variables into the messages or instructions defined in the AI Config variation. If a variation includes multiple messages, all messages are customized and returned.

If the SDK cannot retrieve the variation, such as when the AI Config key does not exist or LaunchDarkly is unreachable, the SDK returns the fallback value.

### Syntax for customization

When you create a message or instruction in an AI Config variation, use the following syntax to substitute context attributes or other variables.

* Use double curly braces to indicate variables provided by your application. For example:
  * Enter `This is an {{ example }}` in the message or instruction in the LaunchDarkly UI. Variable names cannot include a period (`.`).
  * In the SDK, pass a dictionary or key-value pair with the key `example` and the value to substitute.

* Use double curly braces with the `ldctx` prefix and dot (`.`) notation to reference [context attributes](/home/flags/context-attributes). For example:
  * Enter `Describe the typical weather in {{ ldctx.city }}` to substitute the `city` attribute from each context that encounters the AI Config.
  * Context attribute names cannot include a period (`.`). To reference nested attributes, use dot notation in the message or instruction. For example, if the context includes an `address` object with a `city` field, use `{{ ldctx.address.city }}`.
  * In the SDK, the context is a required parameter. You do not need to pass additional variables when using `ldctx`.

### Customization is based on context

Customization adds a [context](/home/getting-started/vocabulary#context) to the **Contexts** list if a context with the same key does not already exist. Each SDK evaluates the AI Config using only the context object you provide at runtime.

The SDK does not automatically use attributes shown on the **Contexts** list, and attributes are not synchronized across SDK instances. Provide all required attributes with each customization to ensure variables in messages or instructions are substituted correctly. To learn more, read [Context configuration](/sdk/features/context-config/).

## AI SDKs

This feature is available for the following AI SDKs:

* [.NET AI](#net-ai)
* [Go AI](#go-ai)
* [Node.js (server-side) AI](#nodejs-server-side-ai)
* [Python AI](#python-ai)
* [Ruby AI](#ruby-ai)

### .NET AI

<Accordion title="Expand .NET AI SDK code sample">
  Use the `Config` function to customize an AI Config. Customization substitutes context attributes and variables into the prompt messages defined in the AI Config variation. You must call `Config` each time you generate content from your AI model.

  The `Config` function takes the AI Config key, a `Context`, a [fallback value](/home/getting-started/vocabulary#fallback-value), and optional additional variables to substitute into your prompt. It performs the evaluation, then returns the customized prompt and model along with a tracker instance for recording prompt metrics. You can pass the customized prompt directly to your AI.

  The fallback value is the value of the AI Config variation that your application should use in the event of an error, for example, if the AI Config key is not valid, or if there is a problem connecting to LaunchDarkly. You can use `LdAiConfig.Disabled` as a fallback value and handle the disabled case in your application.

  Alternatively, you can create a custom `LdAiConfig` object using `LdAiConfig.New()`.

  Here is an example of calling the `Config` method:

  <CodeGroup>
    ```csharp title=".NET AI SDK" theme={null}
          var fallbackConfig = LdAiConfig.New()
            .SetEnabled(false)
            .Build()

          var tracker = aiClient.Config(
            "example-ai-config-key",
            context,
            fallbackConfig,
            new Dictionary<string, object> {
              { "exampleCustomVariable", "exampleCustomValue" }
            }
          );

          if (tracker.Config.Enabled == true) {

            // Send a request to your AI provider, using the details from the customized Config

          } else {

            // Application path to take when the tracker.Config is disabled

          }

    ```
  </CodeGroup>

  After the function call, you can view the context that you provided to it on the **Contexts** list.

  To learn more, read [`Config`](https://launchdarkly.github.io/dotnet-core/pkgs/sdk/server-ai/api/LaunchDarkly.Sdk.Server.Ai.LdAiClient.html#LaunchDarkly_Sdk_Server_Ai_LdAiClient_Config_System_String_LaunchDarkly_Sdk_Context_LaunchDarkly_Sdk_Server_Ai_Config_LdAiConfig_System_Collections_Generic_IReadOnlyDictionary_System_String_System_Object__).
</Accordion>

### Go AI

<Accordion title="Expand Go AI SDK code sample">
  Use the `Config()` function to customize an AI Config. Customization substitutes context attributes and variables into the prompt messages defined in the AI Config variation.

  The `Config()` function takes an AI Config key, a context, and a [fallback value](/home/getting-started/vocabulary#fallback-value). It performs the evaluation and returns a `Config` object with the customized messages and model, along with a `Tracker` object to capture performance metrics. You can pass the customized messages directly to your AI.

  The fallback value is used when an error occurs, such as when the AI Config key is invalid or LaunchDarkly is unreachable. You can use an empty, disabled `Config` as a fallback value by calling `ldai.Disabled()` and handle the disabled case in your application. Alternatively, you can create a custom `Config` using `NewConfig`.

  Here is an example of calling the `Config()` method:

  <CodeGroup>
    ```go title="Go AI SDK" theme={null}
          fallbackValue := NewConfig().Build() // by default, the Config is disabled

          cfg, tracker := aiClient.Config("example-ai-config-key", context, fallbackValue, map[string]interface{}{"exampleCustomVariable": "exampleCustomValue"})

          if cfg.Enabled() {

            // Send a request to your AI provider, using details from the customized cfg

          } else {

            // Application path to take when the cfg is disabled

          }

    ```
  </CodeGroup>

  After the function call, you can view the context that you provided to it on the **Contexts** list.

  To learn more, read [`Config`](https://pkg.go.dev/github.com/launchdarkly/go-server-sdk/ldai#Config).
</Accordion>

### Node.js (server-side) AI

<Accordion title="Expand Node.js (server-side) AI SDK code sample">
  The `completionConfig()`, `agentConfig()`, and `agentConfigs()` functions customize the AI Config at runtime. Customization substitutes context attributes and optional variables into the messages or instructions defined in the AI Config variation.

  The customization behavior depends on whether the AI Config uses completion mode or agent mode. You select the mode when you create the AI Config in the LaunchDarkly UI.

  #### Customize AI Configs in completion mode

  In completion mode, each AI Config variation includes a single set of roles and messages used to prompt your generative AI model.

  In `completion` mode, use `completionConfig()` to customize the AI Config. The `completionConfig` function takes the AI Config key, a `Context`, a [fallback value](/home/getting-started/vocabulary#fallback-value), and optional additional variables to substitute into your prompt. It performs the evaluation, then returns the customized prompt and model along with a tracker instance for recording prompt metrics. You can pass the customized prompt directly to your AI.

  The fallback value is used when an error occurs, such as when the AI Config key is invalid or LaunchDarkly is unreachable. You can use an empty, disabled configuration as a fallback value and handle the disabled case in your application. Alternatively, you can construct a fallback configuration using values from an AI Config variation defined in the LaunchDarkly UI.

  Here is an example of calling the `completionConfig()` method:

  <CodeGroup>
    ```ts title="Customize an AI Config in completion mode" theme={null}
          const fallbackConfig = { enabled: false };

          const aiConfig: LDAIConfig = await aiClient.completionConfig(
            'example-ai-config-key',
            context,
            fallbackConfig,
            { exampleCustomVariable: 'exampleCustomValue' },
          );

          if (aiConfig.enabled) {
            // Send a request to your AI provider using the customized config
          } else {
            // Application path to take when the AI Config is disabled
          }
    ```
  </CodeGroup>

  #### Customize AI Configs in agent mode

  In agent mode, each AI Config variation includes a set of instructions that enable multi-step workflows.

  In `agent` mode, use `agentConfig()` or `agentConfigs()` to customize the AI Config. The `agentConfig()` function customizes a single AI Config agent, while the `agentConfigs()` function customizes an array of agent configurations.

  The instructions returned by the SDK come directly from the instructions you define for the AI Config variation in the LaunchDarkly UI. The goal or task shown in the UI is delivered unchanged as the `instructions` field in the SDK.

  Customization requires an AI Config key, a fallback value, optional variables, and a context. Both functions perform the evaluation and return the customized instructions along with a tracker instance for recording metrics. If the SDK cannot perform the evaluation or LaunchDarkly is unreachable, it returns the fallback value.

  For example, you might use an empty, disabled agent-mode configuration as a fallback value and handle the disabled case in your application.

  Here is an example of customizing an AI Config in agent mode:

  <CodeGroup>
    ```python title="Customize an AI Config in agent mode" theme={null}
          agent_config = LDAIAgentConfig(
            key='example-ai-config-key',
            default_value=LDAIAgentDefaults(
              enabled=False
            ),
            variables={ 'example_custom_variable': 'example_custom_value' }
          )

          const agent: LDAIAgentConfig = await aiClient.agentConfig(
            'example-ai-config-key',
            context,
            fallbackConfig,
            { 'exampleCustomVariable': 'exampleCustomValue' },
          );
    ```
  </CodeGroup>

  To learn more, read [agent](https://launchdarkly-python-sdk-ai.readthedocs.io/en/latest/api-main.html#ldai.client.LDAIClient.agent) and [agents](https://launchdarkly-python-sdk-ai.readthedocs.io/en/latest/api-main.html#ldai.client.LDAIClient.agents).
</Accordion>

### Python AI

<Accordion title="Expand Python AI SDK code sample">
  The `completion_config()`, `agent_config()`, and `agent_configs()` functions customize the AI Config at runtime. Customization substitutes context attributes and optional variables into the messages or instructions defined in the AI Config variation.

  The customization behavior depends on whether the AI Config uses completion mode or agent mode. You select the mode when you create the AI Config in the LaunchDarkly UI.

  #### Customize AI Configs in completion mode

  In completion mode, each AI Config variation includes a single set of roles and messages used to prompt the generative AI model.

  In `completion` mode, use `completion_config()` to customize the AI Config. The `completion_config()` function takes an AI Config key, a context, and a fallback value. It performs the evaluation, then returns the customized messages and model along with a tracker instance for recording metrics.

  The fallback value is used when an error occurs, such as when the AI Config key is invalid or LaunchDarkly is unreachable. You can use an empty, disabled configuration as a fallback value and handle the disabled case in your application. Alternatively, you can construct a fallback configuration using values from an AI Config variation defined in the LaunchDarkly UI.

  Here is an example of calling the `completion_config()` method:

  <CodeGroup>
    ```python title="Customize an AI Config in completion mode" theme={null}
          key = 'example-ai-config-key'
          context = Context.builder('example-context-key') \
            .kind('user') \
            .set('name', 'Sandy') \
            .build()
          fallback_value = AICompletionConfigDefault(enabled=False)
          variables = { 'example_custom_variable': 'example_custom_value' }

          config, tracker = aiclient.completion_config(key, context, fallback_value, variables)

          if config.enabled:
            # Send a request to your AI provider using the customized config
          else:
            # Application path to take when the config is disabled
    ```
  </CodeGroup>

  After the function call, you can view the context that you provided to it on the **Contexts** list.

  To learn more, read [`config`](https://launchdarkly-python-sdk-ai.readthedocs.io/en/latest/api-main.html#ldai.client.LDAIClient.config).

  #### Customize AI Configs in agent mode

  In agent mode, each AI Config variation includes a set of instructions that enable multi-step workflows.

  In `agent` mode, use `agent_config()` or `agent_configs()` to customize the AI Config. The `agent_config()` function customizes a single AI Config agent, while the `agent_configs()` function customizes a list of them.

  The instructions returned by the SDK come directly from the instructions you define for the AI Config variation in the LaunchDarkly UI. The goal or task shown in the UI is delivered unchanged as the `instructions` field in the SDK.

  Customization requires an AI Config key, a fallback value, optional variables, and a context. Both functions perform the evaluation and return the customized instructions along with a tracker instance for recording metrics. If the SDK cannot perform the evaluation or LaunchDarkly is unreachable, it returns the fallback value.

  For example, you might use an empty, disabled agent-mode configuration as a fallback value and handle the disabled case in your application.

  Here is an example of customizing an AI Config in agent mode:

  <CodeGroup>
    ```python title="Customize an AI Config in agent mode" theme={null}
          from ldai import AIAgentConfigDefault

          agent = aiclient.agent_config(
            'example-ai-config-key',
            context,
            AIAgentConfigDefault(
              enabled=False
            ),
            { 'example_custom_variable': 'example_custom_value'}
          )
    ```
  </CodeGroup>
</Accordion>

### Ruby AI

<Accordion title="Expand Ruby AI SDK code sample">
  Use the `config` function to customize an AI Config. Customization substitutes context attributes and optional variables into the prompt messages defined in the AI Config variation. You must call `config` each time you generate content from your AI model.

  The `config` function takes an AI Config key, a `Context`, a [fallback value](/home/getting-started/vocabulary#fallback-value), and optional variables for substitution. It performs the evaluation and returns the customized prompt and model along with a tracker instance for recording metrics. You can pass the customized prompt directly to your AI provider.

  The fallback value is used when an error occurs, such as when the AI Config key is invalid or LaunchDarkly is unreachable. You can use an empty, disabled configuration as a fallback value and handle the disabled case in your application. Alternatively, you can construct a fallback configuration using values from an AI Config variation defined in the LaunchDarkly UI.

  Here is an example of calling the `config` method:

  <CodeGroup>
    ```ruby title="Ruby AI SDK" theme={null}
          key = 'example-ai-config-key'
          context = LaunchDarkly::LDContext.create({ key: 'example-user-key', kind: 'user', name: 'Sandy' })
          fallback_value = LaunchDarkly::AI::AIConfig.new(enabled: false)
          variables = { 'example_custom_variable' => 'example_custom_value' }

          ai_config = ai_client.config(key, context, fallback_value, variables)

          if ai_config.enabled
            # Send a request to your AI provider using the customized config
          else
            # Application path to take when the AI Config is disabled
          end
    ```

    After the function call, you can view the context that you provided to it on the **Contexts** list.

    To learn more, read [`config`](https://launchdarkly.github.io/ruby-server-sdk-ai/LaunchDarkly/Server/AI/Client.html#config-instance_method).
  </CodeGroup>
</Accordion>