Add langchain provider package

Author: edwinokonkwo

packages/ai-providers/server-ai-langchain/README.md

@@ -1,23 +1,195 @@
 # LaunchDarkly AI SDK - LangChain Provider
 
-This package provides LangChain integration for the LaunchDarkly Server-Side AI SDK.
+[![PyPI](https://img.shields.io/pypi/v/launchdarkly-server-sdk-ai-langchain.svg)](https://pypi.org/project/launchdarkly-server-sdk-ai-langchain/)
 
-## Status
-
-🚧 **Coming Soon** - This package is a placeholder for future LangChain integration.
+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
 
 ```bash
 pip install launchdarkly-server-sdk-ai-langchain
 ```
 
+You'll also need to install the LangChain provider packages for the models you want to use:
+
+```bash
+# For OpenAI
+pip install langchain-openai
+
+# For Anthropic
+pip install langchain-anthropic
+
+# For Google
+pip install langchain-google-genai
+```
+
+## Quick Start
+
+```python
+import asyncio
+from ldclient import LDClient, Config, Context
+from ldai import init
+from ldai_langchain import LangChainProvider
+
+# Initialize LaunchDarkly client
+ld_client = LDClient(Config("your-sdk-key"))
+ai_client = init(ld_client)
+
+# Get AI configuration
+context = Context.builder("user-123").build()
+config = ai_client.config("ai-config-key", context, {})
+
+async def main():
+    # Create a LangChain provider from the AI configuration
+    provider = await LangChainProvider.create(config)
+
+    # Use the provider to invoke the model
+    from ldai.models import LDMessage
+    messages = [
+        LDMessage(role="system", content="You are a helpful assistant."),
+        LDMessage(role="user", content="Hello, how are you?"),
+    ]
+    
+    response = await provider.invoke_model(messages)
+    print(response.message.content)
+
+asyncio.run(main())
+```
+
 ## Usage
 
+### Using LangChainProvider with the Create Factory
+
+The simplest way to use the LangChain provider is with the static `create` factory method, which automatically creates the appropriate LangChain model based on your LaunchDarkly AI configuration:
+
 ```python
-# Coming soon
+from ldai_langchain import LangChainProvider
+
+# Create provider from AI configuration
+provider = await LangChainProvider.create(ai_config)
+
+# Invoke the model
+response = await provider.invoke_model(messages)
 ```
 
+### Using an Existing LangChain Model
+
+If you already have a LangChain model configured, you can use it directly:
+
+```python
+from langchain_openai import ChatOpenAI
+from ldai_langchain import LangChainProvider
+
+# Create your own LangChain model
+llm = ChatOpenAI(model="gpt-4", temperature=0.7)
+
+# Wrap it with LangChainProvider
+provider = LangChainProvider(llm)
+
+# Use with LaunchDarkly tracking
+response = await provider.invoke_model(messages)
+```
+
+### Structured Output
+
+The provider supports structured output using LangChain's `with_structured_output`:
+
+```python
+response_structure = {
+    "type": "object",
+    "properties": {
+        "sentiment": {"type": "string", "enum": ["positive", "negative", "neutral"]},
+        "confidence": {"type": "number"},
+    },
+    "required": ["sentiment", "confidence"],
+}
+
+result = await provider.invoke_structured_model(messages, response_structure)
+print(result.data)  # {"sentiment": "positive", "confidence": 0.95}
+```
+
+### Tracking Metrics
+
+Use the provider with LaunchDarkly's tracking capabilities:
+
+```python
+# Get the AI config with tracker
+config = ai_client.config("ai-config-key", context, {})
+
+# Create provider
+provider = await LangChainProvider.create(config)
+
+# Track metrics automatically
+async def invoke():
+    return await provider.invoke_model(messages)
+
+response = await config.tracker.track_metrics_of(
+    invoke,
+    lambda r: r.metrics
+)
+```
+
+### Static Utility Methods
+
+The `LangChainProvider` class provides several utility methods:
+
+#### Converting Messages
+
+```python
+from ldai.models import LDMessage
+from ldai_langchain import LangChainProvider
+
+messages = [
+    LDMessage(role="system", content="You are helpful."),
+    LDMessage(role="user", content="Hello!"),
+]
+
+# Convert to LangChain messages
+langchain_messages = LangChainProvider.convert_messages_to_langchain(messages)
+```
+
+#### Extracting Metrics
+
+```python
+from ldai_langchain import LangChainProvider
+
+# After getting a response from LangChain
+metrics = LangChainProvider.get_ai_metrics_from_response(ai_message)
+print(f"Success: {metrics.success}")
+print(f"Tokens used: {metrics.usage.total if metrics.usage else 'N/A'}")
+```
+
+#### Provider Name Mapping
+
+```python
+# Map LaunchDarkly provider names to LangChain provider names
+langchain_provider = LangChainProvider.map_provider("gemini")  # Returns "google-genai"
+```
+
+## API Reference
+
+### LangChainProvider
+
+#### Constructor
+
+```python
+LangChainProvider(llm: BaseChatModel, logger: Optional[Any] = None)
+```
+
+#### Static Methods
+
+- `create(ai_config: AIConfigKind, logger: Optional[Any] = None) -> LangChainProvider` - Factory method to create a provider from AI configuration
+- `convert_messages_to_langchain(messages: List[LDMessage]) -> List[BaseMessage]` - Convert LaunchDarkly messages to LangChain messages
+- `get_ai_metrics_from_response(response: AIMessage) -> LDAIMetrics` - Extract metrics from a LangChain response
+- `map_provider(ld_provider_name: str) -> str` - Map LaunchDarkly provider names to LangChain names
+- `create_langchain_model(ai_config: AIConfigKind) -> BaseChatModel` - Create a LangChain model from AI configuration
+
+#### Instance Methods
+
+- `invoke_model(messages: List[LDMessage]) -> ChatResponse` - Invoke the model with messages
+- `invoke_structured_model(messages: List[LDMessage], response_structure: Dict[str, Any]) -> StructuredResponse` - Invoke with structured output
+- `get_chat_model() -> BaseChatModel` - Get the underlying LangChain model
+
 ## Documentation
 
 For full documentation, please refer to the [LaunchDarkly AI SDK documentation](https://docs.launchdarkly.com/sdk/ai/python).

packages/ai-providers/server-ai-langchain/pyproject.toml

@@ -25,8 +25,8 @@ packages = [{ include = "ldai_langchain", from = "src" }]
 [tool.poetry.dependencies]
 python = ">=3.9,<4"
 launchdarkly-server-sdk-ai = ">=0.10.1"
-# langchain-core = ">=0.1.0"  # Uncomment when implementing
-
+langchain-core = ">=0.2.0"
+langchain = ">=0.2.0"
 
 [tool.poetry.group.dev.dependencies]
 pytest = ">=2.8"
@@ -44,6 +44,7 @@ non_interactive = true
 [tool.pytest.ini_options]
 addopts = ["-ra"]
 testpaths = ["tests"]
+asyncio_mode = "auto"
 
 
 [build-system]

packages/ai-providers/server-ai-langchain/src/ldai_langchain/__init__.py

@@ -1,14 +1,15 @@
 """LaunchDarkly AI SDK - LangChain Provider.
 
-This package provides LangChain integration for the LaunchDarkly Server-Side AI SDK.
+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.
 """
 
-__version__ = "0.1.0"
+from ldai_langchain.langchain_provider import LangChainProvider
 
-# Placeholder for future LangChain provider implementation
-# from ldai_langchain.langchain_provider import LangChainProvider
+__version__ = "0.1.0"
 
 __all__ = [
     '__version__',
-    # 'LangChainProvider',  # Uncomment when implemented
+    'LangChainProvider',
 ]