datarobot-genai 0.2.26__tar.gz → 0.2.31__tar.gz

{datarobot_genai-0.2.26 → datarobot_genai-0.2.31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datarobot-genai
-Version: 0.2.26
+Version: 0.2.31
 Summary: Generic helpers for GenAI
 Project-URL: Homepage, https://github.com/datarobot-oss/datarobot-genai
 Author: DataRobot, Inc.

{datarobot_genai-0.2.26 → datarobot_genai-0.2.31}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "datarobot-genai"
-version = "0.2.26"
+version = "0.2.31"
 description = "Generic helpers for GenAI"
 readme = "README.md"
 requires-python = ">=3.10, <3.13"

{datarobot_genai-0.2.26 → datarobot_genai-0.2.31}/src/datarobot_genai/drmcp/__init__.py

@@ -19,11 +19,11 @@ A reusable library for building Model Context Protocol (MCP) servers with DataRo
 """
 
 # Export main server components
+from datarobot_genai.drmcp.test_utils.clients.openai import OpenAILLMMCPClient
 from datarobot_genai.drmcp.test_utils.mcp_utils_ete import ete_test_mcp_session
 from datarobot_genai.drmcp.test_utils.mcp_utils_ete import get_dr_mcp_server_url
 from datarobot_genai.drmcp.test_utils.mcp_utils_ete import get_headers
 from datarobot_genai.drmcp.test_utils.mcp_utils_integration import integration_test_mcp_session
-from datarobot_genai.drmcp.test_utils.openai_llm_mcp_client import LLMMCPClient
 from datarobot_genai.drmcp.test_utils.tool_base_ete import ETETestExpectations
 from datarobot_genai.drmcp.test_utils.tool_base_ete import ToolBaseE2E
 from datarobot_genai.drmcp.test_utils.tool_base_ete import ToolCallTestExpectations
@@ -70,7 +70,7 @@ __all__ = [
     "get_dr_mcp_server_url",
     "get_headers",
     "ete_test_mcp_session",
-    "LLMMCPClient",
+    "OpenAILLMMCPClient",
     "ETETestExpectations",
     "ToolBaseE2E",
     "ToolCallTestExpectations",

{datarobot_genai-0.2.26 → datarobot_genai-0.2.31}/src/datarobot_genai/drmcp/core/config.py

@@ -31,6 +31,124 @@ from .constants import DEFAULT_DATAROBOT_ENDPOINT
 from .constants import RUNTIME_PARAM_ENV_VAR_NAME_PREFIX
 
 
+class MCPToolConfig(BaseSettings):
+    """Tool configuration for MCP server."""
+
+    enable_predictive_tools: bool = Field(
+        default=True,
+        validation_alias=AliasChoices(
+            RUNTIME_PARAM_ENV_VAR_NAME_PREFIX + "ENABLE_PREDICTIVE_TOOLS",
+            "ENABLE_PREDICTIVE_TOOLS",
+        ),
+        description="Enable/disable predictive tools",
+    )
+
+    enable_jira_tools: bool = Field(
+        default=False,
+        validation_alias=AliasChoices(
+            RUNTIME_PARAM_ENV_VAR_NAME_PREFIX + "ENABLE_JIRA_TOOLS",
+            "ENABLE_JIRA_TOOLS",
+        ),
+        description="Enable/disable Jira tools",
+    )
+
+    enable_confluence_tools: bool = Field(
+        default=False,
+        validation_alias=AliasChoices(
+            RUNTIME_PARAM_ENV_VAR_NAME_PREFIX + "ENABLE_CONFLUENCE_TOOLS",
+            "ENABLE_CONFLUENCE_TOOLS",
+        ),
+        description="Enable/disable Confluence tools",
+    )
+
+    enable_gdrive_tools: bool = Field(
+        default=False,
+        validation_alias=AliasChoices(
+            RUNTIME_PARAM_ENV_VAR_NAME_PREFIX + "ENABLE_GDRIVE_TOOLS",
+            "ENABLE_GDRIVE_TOOLS",
+        ),
+        description="Enable/disable GDrive tools",
+    )
+
+    enable_microsoft_graph_tools: bool = Field(
+        default=False,
+        validation_alias=AliasChoices(
+            RUNTIME_PARAM_ENV_VAR_NAME_PREFIX + "ENABLE_MICROSOFT_GRAPH_TOOLS",
+            "ENABLE_MICROSOFT_GRAPH_TOOLS",
+        ),
+        description="Enable/disable Sharepoint tools",
+    )
+
+    is_atlassian_oauth_provider_configured: bool = Field(
+        default=False,
+        validation_alias=AliasChoices(
+            RUNTIME_PARAM_ENV_VAR_NAME_PREFIX + "IS_ATLASSIAN_OAUTH_PROVIDER_CONFIGURED",
+            "IS_ATLASSIAN_OAUTH_PROVIDER_CONFIGURED",
+        ),
+        description="Whether Atlassian OAuth provider is configured for Atlassian integration",
+    )
+
+    @property
+    def is_atlassian_oauth_configured(self) -> bool:
+        """Check if Atlassian OAuth is configured via provider flag or environment variables."""
+        return self.is_atlassian_oauth_provider_configured or bool(
+            os.getenv("ATLASSIAN_CLIENT_ID") and os.getenv("ATLASSIAN_CLIENT_SECRET")
+        )
+
+    is_google_oauth_provider_configured: bool = Field(
+        default=False,
+        validation_alias=AliasChoices(
+            RUNTIME_PARAM_ENV_VAR_NAME_PREFIX + "IS_GOOGLE_OAUTH_PROVIDER_CONFIGURED",
+            "IS_GOOGLE_OAUTH_PROVIDER_CONFIGURED",
+        ),
+        description="Whether Google OAuth provider is configured for Google integration",
+    )
+
+    @property
+    def is_google_oauth_configured(self) -> bool:
+        return self.is_google_oauth_provider_configured or bool(
+            os.getenv("GOOGLE_CLIENT_ID") and os.getenv("GOOGLE_CLIENT_SECRET")
+        )
+
+    is_microsoft_oauth_provider_configured: bool = Field(
+        default=False,
+        validation_alias=AliasChoices(
+            RUNTIME_PARAM_ENV_VAR_NAME_PREFIX + "IS_MICROSOFT_OAUTH_PROVIDER_CONFIGURED",
+            "IS_MICROSOFT_OAUTH_PROVIDER_CONFIGURED",
+        ),
+        description="Whether Microsoft OAuth provider is configured for Microsoft integration",
+    )
+
+    @property
+    def is_microsoft_oauth_configured(self) -> bool:
+        return self.is_microsoft_oauth_provider_configured or bool(
+            os.getenv("MICROSOFT_CLIENT_ID") and os.getenv("MICROSOFT_CLIENT_SECRET")
+        )
+
+    @field_validator(
+        "enable_predictive_tools",
+        "enable_jira_tools",
+        "enable_confluence_tools",
+        "enable_gdrive_tools",
+        "enable_microsoft_graph_tools",
+        "is_atlassian_oauth_provider_configured",
+        "is_google_oauth_provider_configured",
+        "is_microsoft_oauth_provider_configured",
+        mode="before",
+    )
+    @classmethod
+    def validate_runtime_params(cls, v: Any) -> Any:
+        """Validate runtime parameters."""
+        return extract_datarobot_runtime_param_payload(v)
+
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        case_sensitive=False,
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+
 class MCPServerConfig(BaseSettings):
     """MCP Server configuration using pydantic settings."""
 
@@ -188,86 +306,11 @@ class MCPServerConfig(BaseSettings):
         ),
         description="Enable/disable memory management",
     )
-    enable_predictive_tools: bool = Field(
-        default=True,
-        validation_alias=AliasChoices(
-            RUNTIME_PARAM_ENV_VAR_NAME_PREFIX + "ENABLE_PREDICTIVE_TOOLS",
-            "ENABLE_PREDICTIVE_TOOLS",
-        ),
-        description="Enable/disable predictive tools",
-    )
 
-    # Jira tools
-    enable_jira_tools: bool = Field(
-        default=False,
-        validation_alias=AliasChoices(
-            RUNTIME_PARAM_ENV_VAR_NAME_PREFIX + "ENABLE_JIRA_TOOLS",
-            "ENABLE_JIRA_TOOLS",
-        ),
-        description="Enable/disable Jira tools",
+    tool_config: MCPToolConfig = Field(
+        default_factory=MCPToolConfig,
+        description="Tool configuration",
     )
-    is_jira_oauth_provider_configured: bool = Field(
-        default=False,
-        validation_alias=AliasChoices(
-            RUNTIME_PARAM_ENV_VAR_NAME_PREFIX + "IS_JIRA_OAUTH_PROVIDER_CONFIGURED",
-            "IS_JIRA_OAUTH_PROVIDER_CONFIGURED",
-        ),
-        description="Whether Jira OAuth provider is configured for Jira integration",
-    )
-
-    @property
-    def is_jira_oauth_configured(self) -> bool:
-        return self.is_jira_oauth_provider_configured or bool(
-            os.getenv("JIRA_CLIENT_ID") and os.getenv("JIRA_CLIENT_SECRET")
-        )
-
-    # Confluence tools
-    enable_confluence_tools: bool = Field(
-        default=False,
-        validation_alias=AliasChoices(
-            RUNTIME_PARAM_ENV_VAR_NAME_PREFIX + "ENABLE_CONFLUENCE_TOOLS",
-            "ENABLE_CONFLUENCE_TOOLS",
-        ),
-        description="Enable/disable Confluence tools",
-    )
-    is_confluence_oauth_provider_configured: bool = Field(
-        default=False,
-        validation_alias=AliasChoices(
-            RUNTIME_PARAM_ENV_VAR_NAME_PREFIX + "IS_CONFLUENCE_OAUTH_PROVIDER_CONFIGURED",
-            "IS_CONFLUENCE_OAUTH_PROVIDER_CONFIGURED",
-        ),
-        description="Whether Confluence OAuth provider is configured for Confluence integration",
-    )
-
-    @property
-    def is_confluence_oauth_configured(self) -> bool:
-        return self.is_confluence_oauth_provider_configured or bool(
-            os.getenv("CONFLUENCE_CLIENT_ID") and os.getenv("CONFLUENCE_CLIENT_SECRET")
-        )
-
-    # Gdrive tools
-    enable_gdrive_tools: bool = Field(
-        default=False,
-        validation_alias=AliasChoices(
-            RUNTIME_PARAM_ENV_VAR_NAME_PREFIX + "ENABLE_GDRIVE_TOOLS",
-            "ENABLE_GDRIVE_TOOLS",
-        ),
-        description="Enable/disable GDrive tools",
-    )
-    is_gdrive_oauth_provider_configured: bool = Field(
-        default=False,
-        validation_alias=AliasChoices(
-            RUNTIME_PARAM_ENV_VAR_NAME_PREFIX + "IS_GDRIVE_OAUTH_PROVIDER_CONFIGURED",
-            "IS_GDRIVE_OAUTH_PROVIDER_CONFIGURED",
-        ),
-        description="Whether GDrive OAuth provider is configured for GDrive integration",
-    )
-
-    @property
-    def is_gdrive_oauth_configured(self) -> bool:
-        return self.is_gdrive_oauth_provider_configured or bool(
-            os.getenv("GDRIVE_CLIENT_ID") and os.getenv("GDRIVE_CLIENT_SECRET")
-        )
 
     @field_validator(
         "otel_attributes",
@@ -291,11 +334,6 @@ class MCPServerConfig(BaseSettings):
         "mcp_server_register_dynamic_tools_on_startup",
         "tool_registration_duplicate_behavior",
         "mcp_server_register_dynamic_prompts_on_startup",
-        "enable_predictive_tools",
-        "enable_jira_tools",
-        "is_jira_oauth_provider_configured",
-        "enable_confluence_tools",
-        "is_confluence_oauth_provider_configured",
         mode="before",
     )
     @classmethod

{datarobot_genai-0.2.26 → datarobot_genai-0.2.31}/src/datarobot_genai/drmcp/core/tool_config.py

@@ -30,6 +30,7 @@ class ToolType(str, Enum):
     JIRA = "jira"
     CONFLUENCE = "confluence"
     GDRIVE = "gdrive"
+    MICROSOFT_GRAPH = "microsoft_graph"
 
 
 class ToolConfig(TypedDict):
@@ -39,7 +40,7 @@ class ToolConfig(TypedDict):
     oauth_check: Callable[["MCPServerConfig"], bool] | None
     directory: str
     package_prefix: str
-    config_field_name: str  # Name of the config field (e.g., "enable_predictive_tools")
+    config_field_name: str
 
 
 # Tool configuration registry
@@ -53,25 +54,32 @@ TOOL_CONFIGS: dict[ToolType, ToolConfig] = {
     ),
     ToolType.JIRA: ToolConfig(
         name="jira",
-        oauth_check=lambda config: config.is_jira_oauth_configured,
+        oauth_check=lambda config: config.tool_config.is_atlassian_oauth_configured,
         directory="jira",
         package_prefix="datarobot_genai.drmcp.tools.jira",
         config_field_name="enable_jira_tools",
     ),
     ToolType.CONFLUENCE: ToolConfig(
         name="confluence",
-        oauth_check=lambda config: config.is_confluence_oauth_configured,
+        oauth_check=lambda config: config.tool_config.is_atlassian_oauth_configured,
         directory="confluence",
         package_prefix="datarobot_genai.drmcp.tools.confluence",
         config_field_name="enable_confluence_tools",
     ),
     ToolType.GDRIVE: ToolConfig(
         name="gdrive",
-        oauth_check=lambda config: config.is_gdrive_oauth_configured,
+        oauth_check=lambda config: config.tool_config.is_google_oauth_configured,
         directory="gdrive",
         package_prefix="datarobot_genai.drmcp.tools.gdrive",
         config_field_name="enable_gdrive_tools",
     ),
+    ToolType.MICROSOFT_GRAPH: ToolConfig(
+        name="microsoft_graph",
+        oauth_check=lambda config: config.tool_config.is_microsoft_oauth_configured,
+        directory="microsoft_graph",
+        package_prefix="datarobot_genai.drmcp.tools.microsoft_graph",
+        config_field_name="enable_microsoft_graph_tools",
+    ),
 }
 
 
@@ -92,12 +100,12 @@ def is_tool_enabled(tool_type: ToolType, config: "MCPServerConfig") -> bool:
     -------
         True if the tool is enabled, False otherwise
     """
-    tool_config = TOOL_CONFIGS[tool_type]
-    enable_config_name = tool_config["config_field_name"]
-    is_enabled = getattr(config, enable_config_name)
+    tool_config_registry = TOOL_CONFIGS[tool_type]
+    enable_config_name = tool_config_registry["config_field_name"]
+    is_enabled = getattr(config.tool_config, enable_config_name)
 
     # If tool is enabled, check OAuth requirements if needed
-    if is_enabled and tool_config["oauth_check"] is not None:
-        return tool_config["oauth_check"](config)
+    if is_enabled and tool_config_registry["oauth_check"] is not None:
+        return tool_config_registry["oauth_check"](config)
 
     return is_enabled

datarobot_genai-0.2.31/src/datarobot_genai/drmcp/test_utils/clients/anthropic.py

@@ -0,0 +1,68 @@
+# Copyright 2026 DataRobot, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Anthropic LLM MCP Client implementation (example).
+
+This is an example implementation showing how easy it is to add a new LLM provider.
+Anthropic's API is OpenAI-compatible, so we can use the OpenAI SDK with their endpoint.
+"""
+
+import openai
+
+from .base import BaseLLMMCPClient
+
+
+class AnthropicMCPClient(BaseLLMMCPClient):
+    """
+    Client for interacting with LLMs via MCP using Anthropic Claude.
+
+    Note: Elicitation is handled at the protocol level by FastMCP's ctx.elicit().
+    Tools using FastMCP's built-in elicitation will work automatically.
+
+    Example:
+        ```python
+        config = {
+            "anthropic_api_key": "sk-ant-...",
+            "model": "claude-3-5-sonnet-20241022",
+        }
+        client = AnthropicMCPClient(str(config))
+        ```
+    """
+
+    def __init__(
+        self,
+        config: str | dict,
+    ):
+        """
+        Initialize the LLM MCP client.
+
+        Args:
+            config: Configuration string or dict with:
+                - anthropic_api_key: Anthropic API key
+                - model: Model name (default: "claude-3-5-sonnet-20241022")
+                - save_llm_responses: Whether to save responses (default: True)
+        """
+        super().__init__(config)
+
+    def _create_llm_client(self, config_dict: dict) -> tuple[openai.OpenAI, str]:
+        """Create the LLM client for Anthropic (OpenAI-compatible endpoint)."""
+        anthropic_api_key = config_dict.get("anthropic_api_key")
+        model = config_dict.get("model", "claude-3-5-sonnet-20241022")
+
+        # Anthropic provides an OpenAI-compatible endpoint
+        client = openai.OpenAI(
+            api_key=anthropic_api_key,
+            base_url="https://api.anthropic.com/v1",
+        )
+        return client, model

datarobot_genai-0.2.26/src/datarobot_genai/drmcp/test_utils/openai_llm_mcp_client.py → datarobot_genai-0.2.31/src/datarobot_genai/drmcp/test_utils/clients/base.py

@@ -1,4 +1,4 @@
-# Copyright 2025 DataRobot, Inc.
+# Copyright 2026 DataRobot, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,7 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+"""Base classes for LLM MCP clients."""
+
 import json
+from abc import ABC
+from abc import abstractmethod
 from ast import literal_eval
 from typing import Any
 
@@ -23,7 +27,7 @@ from mcp.types import ListToolsResult
 from mcp.types import TextContent
 from openai.types.chat.chat_completion import ChatCompletion
 
-from .utils import save_response_to_file
+from ..utils import save_response_to_file
 
 
 class ToolCall:
@@ -44,9 +48,9 @@ class LLMResponse:
         self.tool_results = tool_results
 
 
-class LLMMCPClient:
+class BaseLLMMCPClient(ABC):
     """
-    Client for interacting with LLMs via MCP.
+    Base class for LLM MCP clients.
 
     Note: Elicitation is handled at the protocol level by FastMCP's ctx.elicit().
     Tools using FastMCP's built-in elicitation will work automatically.
@@ -54,54 +58,48 @@ class LLMMCPClient:
 
     def __init__(
         self,
-        config: str,
+        config: str | dict,
     ):
         """
         Initialize the LLM MCP client.
 
         Args:
-            config: Configuration string or dict with:
-                - openai_api_key: OpenAI API key
-                - openai_api_base: Optional Azure OpenAI endpoint
-                - openai_api_deployment_id: Optional Azure deployment ID
-                - openai_api_version: Optional Azure API version
-                - model: Model name (default: "gpt-3.5-turbo")
-                - save_llm_responses: Whether to save responses (default: True)
+            config: Configuration string or dict with provider-specific keys.
         """
-        # Parse config string to extract parameters
+        config_dict = self._parse_config(config)
+        self.openai_client, self.model = self._create_llm_client(config_dict)
+        self.save_llm_responses = config_dict.get("save_llm_responses", True)
+        self.available_tools: list[dict[str, Any]] = []
+        self.available_prompts: list[dict[str, Any]] = []
+        self.available_resources: list[dict[str, Any]] = []
+
+    @staticmethod
+    def _parse_config(config: str | dict) -> dict:
+        """Parse config string to dict."""
         if isinstance(config, str):
             # Try JSON first (safer), fall back to literal_eval for Python dict strings
             try:
-                config_dict = json.loads(config)
+                return json.loads(config)
             except json.JSONDecodeError:
                 # Fall back to literal_eval for Python dict literal strings
-                config_dict = literal_eval(config)
-        else:
-            config_dict = config
-
-        openai_api_key = config_dict.get("openai_api_key")
-        openai_api_base = config_dict.get("openai_api_base")
-        openai_api_deployment_id = config_dict.get("openai_api_deployment_id")
-        model = config_dict.get("model", "gpt-3.5-turbo")
-        save_llm_responses = config_dict.get("save_llm_responses", True)
-
-        if openai_api_base and openai_api_deployment_id:
-            # Azure OpenAI
-            self.openai_client = openai.AzureOpenAI(
-                api_key=openai_api_key,
-                azure_endpoint=openai_api_base,
-                api_version=config_dict.get("openai_api_version", "2024-02-15-preview"),
-            )
-            self.model = openai_api_deployment_id
-        else:
-            # Regular OpenAI
-            self.openai_client = openai.OpenAI(api_key=openai_api_key)  # type: ignore[assignment]
-            self.model = model
+                return literal_eval(config)
+        return config
 
-        self.save_llm_responses = save_llm_responses
-        self.available_tools: list[dict[str, Any]] = []
-        self.available_prompts: list[dict[str, Any]] = []
-        self.available_resources: list[dict[str, Any]] = []
+    @abstractmethod
+    def _create_llm_client(
+        self, config_dict: dict
+    ) -> tuple[openai.OpenAI | openai.AzureOpenAI, str]:
+        """
+        Create the LLM client.
+
+        Args:
+            config_dict: Parsed configuration dictionary
+
+        Returns
+        -------
+            Tuple of (LLM client instance, model name)
+        """
+        pass
 
     async def _add_mcp_tool_to_available_tools(self, mcp_session: ClientSession) -> None:
         """Add a tool to the available tools."""

datarobot_genai-0.2.31/src/datarobot_genai/drmcp/test_utils/clients/dr_gateway.py

@@ -0,0 +1,58 @@
+# Copyright 2026 DataRobot, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""DataRobot LLM Gateway MCP Client implementation."""
+
+import openai
+
+from .base import BaseLLMMCPClient
+
+
+class DRLLMGatewayMCPClient(BaseLLMMCPClient):
+    """
+    Client for interacting with LLMs via MCP using DataRobot LLM Gateway.
+
+    Note: Elicitation is handled at the protocol level by FastMCP's ctx.elicit().
+    Tools using FastMCP's built-in elicitation will work automatically.
+    """
+
+    def __init__(
+        self,
+        config: str | dict,
+    ):
+        """
+        Initialize the LLM MCP client.
+
+        Args:
+            config: Configuration string or dict with:
+                - datarobot_api_token: DataRobot API token
+                - datarobot_endpoint: DataRobot endpoint URL (default: "https://app.datarobot.com/api/v2")
+                - model: Model name (default: "gpt-4o-mini")
+                - save_llm_responses: Whether to save responses (default: True)
+        """
+        super().__init__(config)
+
+    def _create_llm_client(self, config_dict: dict) -> tuple[openai.OpenAI, str]:
+        """Create the LLM client for DataRobot LLM Gateway."""
+        datarobot_api_token = config_dict.get("datarobot_api_token")
+        datarobot_endpoint = config_dict.get(
+            "datarobot_endpoint", "https://app.datarobot.com/api/v2"
+        )
+        model = config_dict.get("model", "gpt-4o-mini")
+
+        # Build gateway URL: {endpoint}/genai/llmgw
+        gateway_url = datarobot_endpoint.rstrip("/") + "/genai/llmgw"
+
+        client = openai.OpenAI(api_key=datarobot_api_token, base_url=gateway_url)
+        return client, model

datarobot_genai-0.2.31/src/datarobot_genai/drmcp/test_utils/clients/openai.py

@@ -0,0 +1,68 @@
+# Copyright 2026 DataRobot, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""OpenAI LLM MCP Client implementation."""
+
+import openai
+
+from .base import BaseLLMMCPClient
+
+
+class OpenAILLMMCPClient(BaseLLMMCPClient):
+    """
+    Client for interacting with LLMs via MCP using OpenAI or Azure OpenAI.
+
+    Note: Elicitation is handled at the protocol level by FastMCP's ctx.elicit().
+    Tools using FastMCP's built-in elicitation will work automatically.
+    """
+
+    def __init__(
+        self,
+        config: str | dict,
+    ):
+        """
+        Initialize the LLM MCP client.
+
+        Args:
+            config: Configuration string or dict with:
+                - openai_api_key: OpenAI API key
+                - openai_api_base: Optional Azure OpenAI endpoint
+                - openai_api_deployment_id: Optional Azure deployment ID
+                - openai_api_version: Optional Azure API version
+                - model: Model name (default: "gpt-3.5-turbo")
+                - save_llm_responses: Whether to save responses (default: True)
+        """
+        super().__init__(config)
+
+    def _create_llm_client(
+        self, config_dict: dict
+    ) -> tuple[openai.OpenAI | openai.AzureOpenAI, str]:
+        """Create the LLM client for OpenAI or Azure OpenAI."""
+        openai_api_key = config_dict.get("openai_api_key")
+        openai_api_base = config_dict.get("openai_api_base")
+        openai_api_deployment_id = config_dict.get("openai_api_deployment_id")
+        model = config_dict.get("model", "gpt-3.5-turbo")
+
+        if openai_api_base and openai_api_deployment_id:
+            # Azure OpenAI
+            client = openai.AzureOpenAI(
+                api_key=openai_api_key,
+                azure_endpoint=openai_api_base,
+                api_version=config_dict.get("openai_api_version", "2024-02-15-preview"),
+            )
+            return client, openai_api_deployment_id
+        else:
+            # Regular OpenAI
+            client = openai.OpenAI(api_key=openai_api_key)  # type: ignore[assignment]
+            return client, model