Getting started with LangGraph and AgentControl configs

pip install "launchdarkly-server-sdk-ai>=0.20.0" "launchdarkly-server-sdk-ai-langchain>=0.7.0" langgraph langchain langchain-core python-dotenv

npm install @launchdarkly/node-server-sdk "@launchdarkly/server-sdk-ai@^0.20.0" "@launchdarkly/server-sdk-ai-langchain@^0.5.5" @langchain/langgraph @langchain/core langchain zod dotenv

import { tool } from '@langchain/core/tools';
import { z } from 'zod';

// tool() types from @langchain/core are deep; cast to any to avoid TS2589
const getOrderStatus = (tool as any)(
  async ({ order_id }: { order_id: string }) => {
    const orders: Record<string, string> = {
      'ORD-123': 'Shipped — arrives Thursday',
      'ORD-456': 'Processing — estimated ship date: tomorrow',
      'ORD-789': 'Delivered on Monday',
    };
    return orders[order_id] || `No order found with ID ${order_id}`;
  },
  {
    name: 'get_order_status',
    description: 'Look up the status of a customer order by order ID',
    schema: z.object({
      order_id: z.string().describe('The order ID to look up'),
    }),
  },
);

// Map tool keys (matching the LaunchDarkly tool keys) to local handlers. The agent
// build step below resolves the active tool list from `agentConfig.model?.parameters?.tools`
// so detaching `get_order_status` from the variation in LaunchDarkly takes effect on
// the next agent invocation, with no code change.
const TOOL_REGISTRY: Record<string, any> = { get_order_status: getOrderStatus };

import { init, LDClient, LDContext } from '@launchdarkly/node-server-sdk';
import { initAi, type LDAIClient, type LDAIAgentConfig } from '@launchdarkly/server-sdk-ai';
import {
  createLangChainModel,
  convertMessagesToLangChain,
  getAIMetricsFromResponse,
  LangChainRunnerFactory,
} from '@launchdarkly/server-sdk-ai-langchain';
import { createReactAgent } from '@langchain/langgraph/prebuilt';
import { MemorySaver } from '@langchain/langgraph';

const sdkKey = process.env.LAUNCHDARKLY_SDK_KEY;
const CONFIG_KEY = 'langgraph-agent';

const ldClient: LDClient = init(sdkKey);

try {
  await ldClient.waitForInitialization({ timeout: 10 });
} catch {
  console.error('LaunchDarkly SDK failed to initialize');
  return;
}

const aiClient: LDAIClient = initAi(ldClient);

const context: LDContext = { kind: 'user', key: 'user-123', name: 'Sandy' };

// Pass a default for improved resiliency when the AgentControl config is unavailable
// or LaunchDarkly is unreachable; omit for a disabled default.
// Example:
//   const fallback = {
//     enabled: true,
//     model: { name: 'gpt-5' },
//     provider: { name: 'openai' },
//     instructions: 'You are a helpful assistant.',
//   };
//   const agentConfig = await aiClient.agentConfig(CONFIG_KEY, context, fallback);
const agentConfig: LDAIAgentConfig = await aiClient.agentConfig(CONFIG_KEY, context);

if (!agentConfig.enabled || !agentConfig.instructions) {
  console.log('Agent Config is disabled — run the Python notebook first');
  await ldClient.close();
  return;
}

// createLangChainModel reads agentConfig.model.name / .parameters
// and picks the right chat model class (OpenAI, Anthropic, …) with no per-provider branching.
const llm = await createLangChainModel(agentConfig);

// Resolve the agent's tool list from the active variation. LaunchDarkly returns
// attached tools under `parameters.tools` in OpenAI function shape; we only need
// the names to look up the local handlers from TOOL_REGISTRY.
const ldToolParams = (agentConfig.model?.parameters as any)?.tools ?? [];
const resolvedTools = ldToolParams
  .map((t: any) => TOOL_REGISTRY[t.name])
  .filter(Boolean);

// MemorySaver gives the ReAct agent short-term memory per thread_id —
// follow-up turns on the same thread see the earlier conversation.
const checkpointer = new MemorySaver();
const agent = createReactAgent({
  llm,
  tools: resolvedTools,
  prompt: agentConfig.instructions,
  checkpointer,
});

// Aggregate token usage across every message with the SDK helper.
function langgraphMetrics(result: any) {
  let input = 0;
  let output = 0;
  let total = 0;
  for (const msg of result.messages || []) {
    const m = LangChainProvider.getAIMetricsFromResponse(msg);
    if (m.usage) {
      input += m.usage.input;
      output += m.usage.output;
      total += m.usage.total;
    }
  }
  return {
    success: true,
    usage: total > 0 ? { total, input, output } : undefined,
  };
}

async function runTurn(input: string, threadId: string): Promise<void> {
  // Each tracker is one execution. trackMetricsOf wraps the call,
  // tracks duration, and tracks success/error itself — no manual catch handling.
  const tracker = agentConfig.createTracker!();
  try {
    const result = await tracker.trackMetricsOf(
      langgraphMetrics,
      () =>
        (agent as any).invoke(
          { messages: [{ role: 'user', content: input }] },
          { configurable: { thread_id: threadId } },
        ),
    );
    // Tool-call telemetry: walk the result messages. (When the JS SDK adds
    // `LangChainProvider.getToolCallsFromResponse`, this collapses to one helper call.)
    for (const msg of result.messages || []) {
      for (const tc of msg.tool_calls || []) {
        tracker.trackToolCall(tc.name);
      }
    }
    const messages = result.messages || [];
    if (messages.length > 0) {
      const content = messages[messages.length - 1].content;
      console.log(`Agent: ${typeof content === 'string' ? content : JSON.stringify(content)}`);
    }
  } catch (error) {
    console.error(`Error: ${error}`);
  }
}

const threadId = 'demo-thread';
await runTurn("What's the status of order ORD-123?", threadId);
await runTurn('What about ORD-456?', threadId);
await runTurn('Summarize both orders for me.', threadId);