Getting started with Anthropic Claude and AI Configs

$
pip install "launchdarkly-server-sdk-ai>=0.17.0"
$
pip install "anthropic>=0.39.0"
$
pip install "python-dotenv>=1.0.0"

1
import os
2
import ldclient
3
from ldclient import Context
4
from ldclient.config import Config
5
from ldai.client import LDAIClient
6
from ldai.providers.types import LDAIMetrics
7
from ldai.tracker import TokenUsage
8
from anthropic import Anthropic
9
from dotenv import load_dotenv
10
11
load_dotenv()
12
13
ANTHROPIC_API_KEY = os.environ.get("ANTHROPIC_API_KEY")
14
SDK_KEY = os.environ.get("LAUNCHDARKLY_SDK_KEY")
15
CONFIG_KEY = "anthropic-assistant"
16
AGENT_CONFIG_KEY = "anthropic-agent"
17
18
anthropic_client = Anthropic(api_key=ANTHROPIC_API_KEY)
19
ldclient.set_config(Config(SDK_KEY))
20
if not ldclient.get().is_initialized():
21
    exit(1)
22
23
ai_client = LDAIClient(ldclient.get())

1
# Define the context for the current user
2
context = Context.builder("user-123") \
3
    .kind("user") \
4
    .name("Sandy") \
5
    .build()
6
7
# Pass a default for improved resiliency when the AI config is unavailable
8
# or LaunchDarkly is unreachable; omit for a disabled default.
9
# Example:
10
#   from ldai.client import AICompletionConfigDefault
11
#   default = AICompletionConfigDefault(
12
#       enabled=True,
13
#       model={"name": "claude-opus-4-7"},
14
#       provider={"name": "anthropic"},
15
#       messages=[{"role": "system", "content": "You are a helpful assistant."}],
16
#   )
17
#   config = ai_client.completion_config(CONFIG_KEY, context, default, variables={"topic": "Python"})
18
19
# Get the AI Config
20
config = ai_client.completion_config(CONFIG_KEY, context, variables={"topic": "Python"})
21
tracker = config.tracker

1
def anthropic_metrics(response) -> LDAIMetrics:
2
    """Convert an Anthropic Messages response into LDAIMetrics. Passed to
3
    tracker.track_metrics_of, which handles duration + success/error itself."""
4
    usage = response.usage
5
    return LDAIMetrics(
6
        success=True,
7
        usage=TokenUsage(
8
            total=usage.input_tokens + usage.output_tokens,
9
            input=usage.input_tokens,
10
            output=usage.output_tokens,
11
        ),
12
    )

1
if config.enabled:
2
    tracker = config.tracker
3
    messages = config.messages or []
4
5
    # Anthropic uses a top-level `system` parameter, not a system role in messages
6
    system = next((m.content for m in messages if m.role == "system"), None)
7
    chat_messages = [{"role": m.role, "content": m.content} for m in messages if m.role != "system"]
8
    chat_messages.append({"role": "user", "content": "How do I read a file in Python?"})
9
10
    params = dict((config.model.to_dict().get("parameters") if config.model else None) or {})
11
    params.setdefault("max_tokens", 1024)
12
13
    response = tracker.track_metrics_of(
14
        lambda: anthropic_client.messages.create(
15
            model=config.model.name,
16
            system=system or "",
17
            messages=chat_messages,
18
            **params,
19
        ),
20
        anthropic_metrics,
21
    )

1
# Same fallback pattern as completion — omit the default for a disabled fallback.
2
agent = ai_client.agent_config(AGENT_CONFIG_KEY, context)
3
4
if agent.enabled:
5
    tracker = agent.tracker
6
    params = dict((agent.model.to_dict().get("parameters") if agent.model else None) or {})
7
    params.setdefault("max_tokens", 1024)
8
9
    # LD returns attached tools under `parameters.tools` in OpenAI's type=function
10
    # shape: [{type:"function", name, description, parameters:{...schema}}].
11
    # Anthropic expects {name, description, input_schema}. Convert and move them
12
    # out of params (they go on the top-level `tools=` argument).
13
    ld_tools = params.pop("tools", []) or []
14
    tools = [
15
        {
16
            "name": t["name"],
17
            "description": t.get("description", ""),
18
            "input_schema": t.get("parameters", {"type": "object", "properties": {}}),
19
        }
20
        for t in ld_tools
21
    ]
22
23
    # Handlers stay in application code — LD stores the schema, the app owns the behavior.
24
    def get_order_status(order_id: str) -> str:
25
        orders = {
26
            "ORD-123": "Shipped — arrives Thursday",
27
            "ORD-456": "Processing — estimated ship date: tomorrow",
28
            "ORD-789": "Delivered on Monday",
29
        }
30
        return orders.get(order_id, f"No order found with ID {order_id}")
31
32
    tool_handlers = {"get_order_status": get_order_status}
33
34
    messages = [{"role": "user", "content": "What's the status of order ORD-123?"}]
35
36
    # Agent loop: call Anthropic, handle tool_use blocks, repeat
37
    MAX_STEPS = 5
38
    for _ in range(MAX_STEPS):
39
        response = tracker.track_metrics_of(
40
            lambda: anthropic_client.messages.create(
41
                model=agent.model.name,
42
                system=agent.instructions,
43
                messages=messages,
44
                tools=tools,
45
                **params,
46
            ),
47
            anthropic_metrics,
48
        )
49
50
        if response.stop_reason != "tool_use":
51
            break
52
53
        # Append assistant turn (preserves tool_use blocks)
54
        messages.append({"role": "assistant", "content": response.content})
55
56
        # Build a single tool_result user turn covering every tool_use block
57
        tool_results = []
58
        for block in response.content:
59
            if block.type != "tool_use":
60
                continue
61
            if block.name not in tool_handlers:
62
                raise ValueError(f"Unknown tool: {block.name}")
63
            result = tool_handlers[block.name](**block.input)
64
            tracker.track_tool_call(block.name)
65
            tool_results.append({
66
                "type": "tool_result",
67
                "tool_use_id": block.id,
68
                "content": result,
69
            })
70
        messages.append({"role": "user", "content": tool_results})

1
ldclient.get().close()

1
# Always flush events before closing — trailing events are at risk of being
2
# lost otherwise, in short-lived scripts and long-running services alike.
3
ldclient.get().flush()
4
ldclient.get().close()

1
import os
2
import ldclient
3
from ldclient import Context
4
from ldclient.config import Config
5
from ldai.client import LDAIClient
6
from ldai.providers.types import LDAIMetrics
7
from ldai.tracker import TokenUsage
8
from anthropic import Anthropic
9
from dotenv import load_dotenv
10
11
load_dotenv()
12
13
ANTHROPIC_API_KEY = os.environ.get("ANTHROPIC_API_KEY")
14
SDK_KEY = os.environ.get("LAUNCHDARKLY_SDK_KEY_ANTHROPIC")
15
16
CONFIG_KEY = "anthropic-assistant"
17
AGENT_CONFIG_KEY = "anthropic-agent"
18
19
20
def anthropic_metrics(response) -> LDAIMetrics:
21
    """Convert an Anthropic Messages response into LDAIMetrics. Passed to
22
    tracker.track_metrics_of, which handles duration + success/error itself."""
23
    usage = response.usage
24
    return LDAIMetrics(
25
        success=True,
26
        usage=TokenUsage(
27
            total=usage.input_tokens + usage.output_tokens,
28
            input=usage.input_tokens,
29
            output=usage.output_tokens,
30
        ),
31
    )
32
33
34
def main():
35
    anthropic_client = Anthropic(api_key=ANTHROPIC_API_KEY)
36
    ldclient.set_config(Config(SDK_KEY))
37
    if not ldclient.get().is_initialized():
38
        return
39
40
    ai_client = LDAIClient(ldclient.get())
41
42
    context = Context.builder("user-123").kind("user").name("Sandy").build()
43
44
    # ===================
45
    # COMPLETION MODE
46
    # ===================
47
48
    # Pass a default for improved resiliency when the AI config is unavailable
49
    # or LaunchDarkly is unreachable; omit for a disabled default.
50
    # Example:
51
    #   from ldai.client import AICompletionConfigDefault
52
    #   default = AICompletionConfigDefault(
53
    #       enabled=True,
54
    #       model={"name": "claude-opus-4-7"},
55
    #       provider={"name": "anthropic"},
56
    #       messages=[{"role": "system", "content": "You are a helpful assistant."}],
57
    #   )
58
    #   config = ai_client.completion_config(CONFIG_KEY, context, default, variables={"topic": "Python"})
59
    config = ai_client.completion_config(CONFIG_KEY, context, variables={"topic": "Python"})
60
61
    if config.enabled:
62
        tracker = config.tracker
63
        messages = config.messages or []
64
65
        # Anthropic uses a top-level `system` parameter, not a system role in messages
66
        system = next((m.content for m in messages if m.role == "system"), None)
67
        chat_messages = [{"role": m.role, "content": m.content} for m in messages if m.role != "system"]
68
        chat_messages.append({"role": "user", "content": "How do I read a file in Python?"})
69
70
        params = dict((config.model.to_dict().get("parameters") if config.model else None) or {})
71
        params.setdefault("max_tokens", 1024)
72
73
        tracker.track_metrics_of(
74
            lambda: anthropic_client.messages.create(
75
                model=config.model.name,
76
                system=system or "",
77
                messages=chat_messages,
78
                **params,
79
            ),
80
            anthropic_metrics,
81
        )
82
83
    # ===================
84
    # AGENT MODE
85
    # ===================
86
87
    # Same fallback pattern as completion — omit the default for a disabled fallback.
88
    agent = ai_client.agent_config(AGENT_CONFIG_KEY, context)
89
90
    if agent.enabled:
91
        tracker = agent.tracker
92
        params = dict((agent.model.to_dict().get("parameters") if agent.model else None) or {})
93
        params.setdefault("max_tokens", 1024)
94
95
        # LD returns attached tools under `parameters.tools` in OpenAI's type=function
96
        # shape: [{type:"function", name, description, parameters:{...schema}}].
97
        # Anthropic expects {name, description, input_schema}. Convert and move them
98
        # out of params (they go on the top-level `tools=` argument).
99
        ld_tools = params.pop("tools", []) or []
100
        tools = [
101
            {
102
                "name": t["name"],
103
                "description": t.get("description", ""),
104
                "input_schema": t.get("parameters", {"type": "object", "properties": {}}),
105
            }
106
            for t in ld_tools
107
        ]
108
109
        # Handlers stay in application code — LD stores the schema, the app owns the behavior.
110
        def get_order_status(order_id: str) -> str:
111
            orders = {
112
                "ORD-123": "Shipped — arrives Thursday",
113
                "ORD-456": "Processing — estimated ship date: tomorrow",
114
                "ORD-789": "Delivered on Monday",
115
            }
116
            return orders.get(order_id, f"No order found with ID {order_id}")
117
118
        tool_handlers = {"get_order_status": get_order_status}
119
120
        messages = [{"role": "user", "content": "What's the status of order ORD-123?"}]
121
122
        # Agent loop: call Anthropic, handle tool_use blocks, repeat
123
        MAX_STEPS = 5
124
        for _ in range(MAX_STEPS):
125
            response = tracker.track_metrics_of(
126
                lambda: anthropic_client.messages.create(
127
                    model=agent.model.name,
128
                    system=agent.instructions,
129
                    messages=messages,
130
                    tools=tools,
131
                    **params,
132
                ),
133
                anthropic_metrics,
134
            )
135
136
            if response.stop_reason != "tool_use":
137
                break
138
139
            # Append assistant turn (preserves tool_use blocks)
140
            messages.append({"role": "assistant", "content": response.content})
141
142
            # Build a single tool_result user turn covering every tool_use block
143
            tool_results = []
144
            for block in response.content:
145
                if block.type != "tool_use":
146
                    continue
147
                if block.name not in tool_handlers:
148
                    raise ValueError(f"Unknown tool: {block.name}")
149
                result = tool_handlers[block.name](**block.input)
150
                tracker.track_tool_call(block.name)
151
                tool_results.append({
152
                    "type": "tool_result",
153
                    "tool_use_id": block.id,
154
                    "content": result,
155
                })
156
            messages.append({"role": "user", "content": tool_results})
157
158
    # Always flush events before closing — trailing events are at risk of being
159
    # lost otherwise, in short-lived scripts and long-running services alike.
160
    ldclient.get().flush()
161
    ldclient.get().close()
162
163
164
if __name__ == "__main__":
165
    main()