completion_config

agent_config

/aiconfig-create

/aiconfig-tools

/aiconfig-targeting

/aiconfig-online-evals

LDClient

ldclient

import ldclient
from ldclient.config import Config
from ldai.client import LDAIClient

ldclient.set_config(Config(os.environ["LD_SDK_KEY"]))
ai_client = LDAIClient(ldclient.get())

import { init } from '@launchdarkly/node-server-sdk';
import { initAi } from '@launchdarkly/server-sdk-ai';

const ldClient = init(process.env.LD_SDK_KEY!);
await ldClient.waitForInitialization({ timeout: 10 });
const aiClient = initAi(ldClient);

from ldai.client import AICompletionConfigDefault, ModelConfig, ProviderConfig, LDMessage

fallback = AICompletionConfigDefault(
    enabled=True,
    model=ModelConfig(name="gpt-4o", parameters={"temperature": 0.7, "maxTokens": 2000}),
    provider=ProviderConfig(name="openai"),
    messages=[LDMessage(role="system", content="You are a helpful assistant...")],
)

response = openai_client.chat.completions.create(
    model="gpt-4o",
    temperature=0.7,
    max_tokens=2000,
    messages=[
        {"role": "system", "content": "You are a helpful assistant..."},
        {"role": "user", "content": user_input},
    ],
)

context = Context.builder(user_id).set("email", user.email).build()
config = ai_client.completion_config("chat-assistant", context, fallback)

if not config.enabled:
    return disabled_response()

params = config.model.parameters or {}
response = openai_client.chat.completions.create(
    model=config.model.name,
    temperature=params.get("temperature"),
    max_tokens=params.get("maxTokens"),
    messages=[m.to_dict() for m in (config.messages or [])] + [
        {"role": "user", "content": user_input},
    ],
)

context = Context.builder(user_id).kind("user").build()
config = ai_client.agent_config("support-agent", context, FALLBACK)

if not config.enabled:
    return disabled_response()

# config is a single AIAgentConfig object — NOT a (config, tracker) tuple.
# The tracker lives at config.tracker.
model_name = f"{config.provider.name}/{config.model.name}"
instructions = config.instructions
params = config.model.parameters or {}

# Pass model_name + instructions into your framework's agent constructor.
# Example: LangGraph create_react_agent
# agent = create_react_agent(
#     model=load_chat_model(model_name),
#     tools=TOOLS,               # Stage 3 will replace this with a config.tools loader
#     prompt=instructions,
# )

from ldai_openai import OpenAIProvider
import openai

client = openai.OpenAI()

def call_openai():
    return client.chat.completions.create(
        model=config.model.name,
        messages=[{"role": "system", "content": config.messages[0].content},
                  {"role": "user", "content": user_prompt}],
    )

try:
    response = config.tracker.track_metrics_of(
        call_openai,
        OpenAIProvider.get_ai_metrics_from_response,
    )
except Exception:
    config.tracker.track_error()
    raise

import { OpenAIProvider } from '@launchdarkly/server-sdk-ai-openai';

try {
  const response = await aiConfig.tracker.trackMetricsOf(
    OpenAIProvider.getAIMetricsFromResponse,
    () => openaiClient.chat.completions.create({
      model: aiConfig.model!.name,
      messages: [...aiConfig.messages, { role: 'user', content: userPrompt }],
    }),
  );
} catch (err) {
  aiConfig.tracker.trackError();
  throw err;
}

from ldai.tracker import FeedbackKind
config.tracker.track_feedback({"kind": FeedbackKind.Positive})

import { LDFeedbackKind } from '@launchdarkly/server-sdk-ai';
aiConfig.tracker.trackFeedback({ kind: LDFeedbackKind.Positive });

from ldai.client import AIJudgeConfigDefault

judge = await ai_client.create_judge(
    judge_key,                               # judge AI Config key in LD
    ld_context,
    AIJudgeConfigDefault(enabled=False),     # fallback: skip eval on SDK miss
)

if judge and judge.enabled:
    result = await judge.evaluate(
        input_text,
        output_text,
        sampling_rate=0.25,                  # optional; default 1.0 (always eval)
    )
    if result:
        config.tracker.track_eval_scores(result.evals)