launchdarkly-server-sdk-ai-langchain 0.7.0

LaunchDarkly AI SDK LangChain Provider

LaunchDarkly AI SDK - LangChain Provider

[!CAUTION] This package is in pre-release and not subject to backwards compatibility guarantees. The API may change based on feedback.

Pin to a specific minor version and review the changelog before upgrading.

This package provides LangChain integration for the LaunchDarkly Server-Side AI SDK, allowing you to use LangChain models and chains with LaunchDarkly's tracking and configuration capabilities.

Installation

pip install launchdarkly-server-sdk-ai-langchain

You'll also need to install the LangChain provider packages for the models you want to use:

# For OpenAI
pip install langchain-openai

# For Anthropic
pip install langchain-anthropic

# For Google
pip install langchain-google-genai

Quick Start

import asyncio
from ldclient import LDClient, Config, Context
from ldai import init
from ldai.models import AICompletionConfigDefault, ModelConfig, ProviderConfig

# Initialize LaunchDarkly client
ld_client = LDClient(Config("your-sdk-key"))
ai_client = init(ld_client)

context = Context.builder("user-123").build()

async def main():
    # Create a ManagedModel backed by the LangChain provider
    model = await ai_client.create_model(
        "ai-config-key",
        context,
        AICompletionConfigDefault(
            enabled=True,
            model=ModelConfig("gpt-4"),
            provider=ProviderConfig("langchain"),
        ),
    )

    if model:
        result = await model.run("Hello, how are you?")
        print(result.content)

asyncio.run(main())

Usage

Using create_model (recommended)

The recommended entry point is LDAIClient.create_model, which evaluates a LaunchDarkly AI config flag, selects the LangChain runner automatically, and returns a ManagedModel that wraps the runner:

model = await ai_client.create_model("ai-config-key", context)

if model:
    result = await model.run("What is feature flagging?")
    print(result.content)

Using the runner directly

If you need to construct a runner manually (e.g. for testing), you can use LangChainRunnerFactory from the ldai_langchain package:

from langchain_openai import ChatOpenAI
from ldai_langchain import LangChainRunnerFactory

llm = ChatOpenAI(model="gpt-4", temperature=0.7)
runner = LangChainModelRunner(llm)

result = await runner.run("Hello!")
print(result.content)

Structured Output

Pass a JSON schema dict as output_type to request structured output:

response_structure = {
    "type": "object",
    "properties": {
        "sentiment": {"type": "string", "enum": ["positive", "negative", "neutral"]},
        "confidence": {"type": "number"},
    },
    "required": ["sentiment", "confidence"],
}

result = await runner.run(messages, output_type=response_structure)
print(result.parsed)  # {"sentiment": "positive", "confidence": 0.95}

Tracking Metrics

ManagedModel.run() automatically tracks metrics via the associated LDAIConfigTracker. For manual tracking, use the tracker directly:

model = await ai_client.create_model("ai-config-key", context)

if model:
    result = await model.run("Explain feature flags.")
    # Metrics are tracked automatically; access them via result.metrics
    print(result.metrics.tokens)

Static Utility Methods

The ldai_langchain helper module provides several utility functions:

Converting Messages

from ldai.models import LDMessage
from ldai_langchain.langchain_helper import convert_messages_to_langchain

messages = [
    LDMessage(role="system", content="You are helpful."),
    LDMessage(role="user", content="Hello!"),
]

langchain_messages = convert_messages_to_langchain(messages)

Extracting Metrics

from ldai_langchain.langchain_helper import get_ai_metrics_from_response

# After getting a response from LangChain
metrics = get_ai_metrics_from_response(ai_message)
print(f"Success: {metrics.success}")
print(f"Tokens used: {metrics.tokens.total if metrics.tokens else 'N/A'}")

Provider Name Mapping

from ldai_langchain.langchain_helper import map_provider_name

# Map LaunchDarkly provider names to LangChain provider names
langchain_provider = map_provider_name("gemini")  # Returns "google-genai"

Documentation

For full documentation, please refer to the LaunchDarkly AI SDK documentation.

Contributing

See CONTRIBUTING.md in the repository root.

License

Apache-2.0