dao-ai 0.0.22__py3-none-any.whl → 0.0.24__py3-none-any.whl

dao_ai/config.py

@@ -666,6 +666,10 @@ class ConnectionModel(BaseModel, HasFullName, IsDatabricksResource):
         return [
             "catalog.connections",
             "serving.serving-endpoints",
+            "mcp.genie",
+            "mcp.functions",
+            "mcp.vectorsearch",
+            "mcp.external",
         ]
 
     def as_resources(self) -> Sequence[DatabricksResource]:
@@ -988,6 +992,7 @@ class McpFunctionModel(BaseFunctionModel, HasFullName):
     transport: TransportType = TransportType.STREAMABLE_HTTP
     command: Optional[str] = "python"
     url: Optional[AnyVariable] = None
+    connection: Optional[ConnectionModel] = None
     headers: dict[str, AnyVariable] = Field(default_factory=dict)
     args: list[str] = Field(default_factory=list)
     pat: Optional[AnyVariable] = None
@@ -1007,8 +1012,12 @@ class McpFunctionModel(BaseFunctionModel, HasFullName):
 
     @model_validator(mode="after")
     def validate_mutually_exclusive(self):
-        if self.transport == TransportType.STREAMABLE_HTTP and not self.url:
-            raise ValueError("url must be provided for STREAMABLE_HTTP transport")
+        if self.transport == TransportType.STREAMABLE_HTTP and not (
+            self.url or self.connection
+        ):
+            raise ValueError(
+                "url or connection must be provided for STREAMABLE_HTTP transport"
+            )
         if self.transport == TransportType.STDIO and not self.command:
             raise ValueError("command must not be provided for STDIO transport")
         if self.transport == TransportType.STDIO and not self.args:
@@ -1157,6 +1166,40 @@ class MemoryModel(BaseModel):
 FunctionHook: TypeAlias = PythonFunctionModel | FactoryFunctionModel | str
 
 
+class PromptModel(BaseModel, HasFullName):
+    model_config = ConfigDict(use_enum_values=True, extra="forbid")
+    schema_model: Optional[SchemaModel] = Field(default=None, alias="schema")
+    name: str
+    description: Optional[str] = None
+    default_template: Optional[str] = None
+    alias: Optional[str] = None
+    version: Optional[int] = None
+    tags: Optional[dict[str, Any]] = Field(default_factory=dict)
+
+    @property
+    def template(self) -> str:
+        from dao_ai.providers.databricks import DatabricksProvider
+
+        provider: DatabricksProvider = DatabricksProvider()
+        prompt: str = provider.get_prompt(self)
+        return prompt
+
+    @property
+    def full_name(self) -> str:
+        if self.schema_model:
+            name: str = ""
+            if self.name:
+                name = f".{self.name}"
+            return f"{self.schema_model.catalog_name}.{self.schema_model.schema_name}{name}"
+        return self.name
+
+    @model_validator(mode="after")
+    def validate_mutually_exclusive(self):
+        if self.alias and self.version:
+            raise ValueError("Cannot specify both alias and version")
+        return self
+
+
 class AgentModel(BaseModel):
     model_config = ConfigDict(use_enum_values=True, extra="forbid")
     name: str
@@ -1164,7 +1207,7 @@ class AgentModel(BaseModel):
     model: LLMModel
     tools: list[ToolModel] = Field(default_factory=list)
     guardrails: list[GuardrailModel] = Field(default_factory=list)
-    prompt: Optional[str] = None
+    prompt: Optional[str | PromptModel] = None
     handoff_prompt: Optional[str] = None
     create_agent_hook: Optional[FunctionHook] = None
     pre_agent_hook: Optional[FunctionHook] = None
@@ -1490,6 +1533,7 @@ class AppConfig(BaseModel):
     tools: dict[str, ToolModel] = Field(default_factory=dict)
     guardrails: dict[str, GuardrailModel] = Field(default_factory=dict)
     memory: Optional[MemoryModel] = None
+    prompts: dict[str, PromptModel] = Field(default_factory=dict)
     agents: dict[str, AgentModel] = Field(default_factory=dict)
     app: Optional[AppModel] = None
     evaluation: Optional[EvaluationModel] = None

dao_ai/prompts.py

@@ -1,4 +1,4 @@
-from typing import Any, Callable, Sequence
+from typing import Any, Callable, Optional, Sequence
 
 from langchain.prompts import PromptTemplate
 from langchain_core.messages import (
@@ -8,18 +8,26 @@ from langchain_core.messages import (
 from langchain_core.runnables import RunnableConfig
 from loguru import logger
 
+from dao_ai.config import PromptModel
 from dao_ai.state import SharedState
 
 
-def make_prompt(base_system_prompt: str) -> Callable[[dict, RunnableConfig], list]:
+def make_prompt(
+    base_system_prompt: Optional[str | PromptModel],
+) -> Callable[[dict, RunnableConfig], list]:
     logger.debug(f"make_prompt: {base_system_prompt}")
 
     def prompt(state: SharedState, config: RunnableConfig) -> list:
         system_prompt: str = ""
         if base_system_prompt:
-            prompt_template: PromptTemplate = PromptTemplate.from_template(
-                base_system_prompt
-            )
+            # Extract template string from PromptModel or use string directly
+            template_str: str
+            if isinstance(base_system_prompt, PromptModel):
+                template_str = base_system_prompt.template
+            else:
+                template_str = base_system_prompt
+
+            prompt_template: PromptTemplate = PromptTemplate.from_template(template_str)
 
             params: dict[str, Any] = {
                 input_variable: "" for input_variable in prompt_template.input_variables

dao_ai/providers/databricks.py

@@ -30,6 +30,7 @@ from databricks.vector_search.index import VectorSearchIndex
 from loguru import logger
 from mlflow import MlflowClient
 from mlflow.entities import Experiment
+from mlflow.entities.model_registry import PromptVersion
 from mlflow.entities.model_registry.model_version import ModelVersion
 from mlflow.models.auth_policy import AuthPolicy, SystemAuthPolicy, UserAuthPolicy
 from mlflow.models.model import ModelInfo
@@ -52,6 +53,7 @@ from dao_ai.config import (
     IndexModel,
     IsDatabricksResource,
     LLMModel,
+    PromptModel,
     SchemaModel,
     TableModel,
     UnityCatalogFunctionSqlModel,
@@ -1023,3 +1025,79 @@ class DatabricksProvider(ServiceProvider):
                 f"Error creating instance role '{role_name}' for database {instance_name}: {e}"
             )
             raise
+
+    def get_prompt(self, prompt_model: PromptModel) -> str:
+        """Load prompt from MLflow Prompt Registry or fall back to default_template."""
+        prompt_name: str = prompt_model.full_name
+
+        # Build prompt URI based on alias, version, or default to latest
+        if prompt_model.alias:
+            prompt_uri = f"prompts:/{prompt_name}@{prompt_model.alias}"
+        elif prompt_model.version:
+            prompt_uri = f"prompts:/{prompt_name}/{prompt_model.version}"
+        else:
+            prompt_uri = f"prompts:/{prompt_name}@latest"
+
+        try:
+            from mlflow.genai.prompts import Prompt
+
+            prompt_obj: Prompt = mlflow.genai.load_prompt(prompt_uri)
+            return prompt_obj.to_single_brace_format()
+
+        except Exception as e:
+            logger.warning(f"Failed to load prompt '{prompt_name}' from registry: {e}")
+
+            if prompt_model.default_template:
+                logger.info(f"Using default_template for '{prompt_name}'")
+                self._sync_default_template_to_registry(
+                    prompt_name, prompt_model.default_template, prompt_model.description
+                )
+                return prompt_model.default_template
+
+            raise ValueError(
+                f"Prompt '{prompt_name}' not found in registry and no default_template provided"
+            ) from e
+
+    def _sync_default_template_to_registry(
+        self, prompt_name: str, default_template: str, description: str | None = None
+    ) -> None:
+        """Register default_template to prompt registry under 'default' alias if changed."""
+        try:
+            # Check if default alias already has the same template
+            try:
+                logger.debug(f"Loading prompt '{prompt_name}' from registry...")
+                existing: PromptVersion = mlflow.genai.load_prompt(
+                    f"prompts:/{prompt_name}@default"
+                )
+                if (
+                    existing.to_single_brace_format().strip()
+                    == default_template.strip()
+                ):
+                    logger.debug(f"Prompt '{prompt_name}' is already up-to-date")
+                    return  # Already up-to-date
+            except Exception:
+                logger.debug(
+                    f"Default alias for prompt '{prompt_name}' doesn't exist yet"
+                )
+
+            # Register new version and set as default alias
+            commit_message = description or "Auto-synced from default_template"
+            prompt_version: PromptVersion = mlflow.genai.register_prompt(
+                name=prompt_name,
+                template=default_template,
+                commit_message=commit_message,
+            )
+
+            logger.debug(f"Setting default alias for prompt '{prompt_name}'")
+            mlflow.genai.set_prompt_alias(
+                name=prompt_name,
+                alias="default",
+                version=prompt_version.version,
+            )
+
+            logger.info(
+                f"Synced prompt '{prompt_name}' v{prompt_version.version} to registry"
+            )
+
+        except Exception as e:
+            logger.warning(f"Failed to sync '{prompt_name}' to registry: {e}")

dao_ai/tools/__init__.py

@@ -7,6 +7,7 @@ from dao_ai.tools.core import (
 from dao_ai.tools.genie import create_genie_tool
 from dao_ai.tools.mcp import create_mcp_tools
 from dao_ai.tools.python import create_factory_tool, create_python_tool
+from dao_ai.tools.slack import create_send_slack_message_tool
 from dao_ai.tools.time import (
     add_time_tool,
     current_time_tool,
@@ -27,6 +28,7 @@ __all__ = [
     "create_hooks",
     "create_mcp_tools",
     "create_python_tool",
+    "create_send_slack_message_tool",
     "create_tools",
     "create_uc_tools",
     "create_vector_search_tool",

dao_ai/tools/mcp.py

@@ -1,10 +1,14 @@
 import asyncio
 from typing import Any, Sequence
 
+from databricks_mcp import DatabricksOAuthClientProvider
 from langchain_core.runnables.base import RunnableLike
 from langchain_core.tools import tool as create_tool
 from langchain_mcp_adapters.client import MultiServerMCPClient
+from langchain_mcp_adapters.tools import load_mcp_tools
 from loguru import logger
+from mcp import ClientSession
+from mcp.client.streamable_http import streamablehttp_client
 from mcp.types import ListToolsResult, Tool
 
 from dao_ai.config import (
@@ -20,98 +24,153 @@ def create_mcp_tools(
     """
     Create tools for invoking Databricks MCP functions.
 
+    Supports both direct MCP connections and UC Connection-based MCP access.
     Uses session-based approach to handle authentication token expiration properly.
+
+    Based on: https://docs.databricks.com/aws/en/generative-ai/mcp/external-mcp
     """
     logger.debug(f"create_mcp_tools: {function}")
 
-    def _create_fresh_connection() -> dict[str, Any]:
-        logger.debug("Creating fresh connection...")
-        """Create connection config with fresh authentication headers."""
-        if function.transport == TransportType.STDIO:
-            return {
-                "command": function.command,
-                "args": function.args,
-                "transport": function.transport,
-            }
-
-        # For HTTP transport, generate fresh headers
-        headers = function.headers.copy() if function.headers else {}
+    # Check if using UC Connection or direct MCP connection
+    if function.connection:
+        # Use UC Connection approach with DatabricksOAuthClientProvider
+        logger.debug(f"Using UC Connection for MCP: {function.connection.name}")
 
-        if "Authorization" not in headers:
-            logger.debug("Generating fresh authentication token for MCP function")
-
-            from dao_ai.config import value_of
-            from dao_ai.providers.databricks import DatabricksProvider
-
-            try:
-                provider = DatabricksProvider(
-                    workspace_host=value_of(function.workspace_host),
-                    client_id=value_of(function.client_id),
-                    client_secret=value_of(function.client_secret),
-                    pat=value_of(function.pat),
-                )
-                headers["Authorization"] = f"Bearer {provider.create_token()}"
-                logger.debug("Generated fresh authentication token")
-            except Exception as e:
-                logger.error(f"Failed to create fresh token: {e}")
+        # Construct URL if not provided
+        if function.url:
+            mcp_url = function.url
+            logger.debug(f"Using provided MCP URL: {mcp_url}")
         else:
-            logger.debug("Using existing authentication token")
+            # Construct URL from workspace host and connection name
+            # Pattern: https://{workspace_host}/api/2.0/mcp/external/{connection_name}
+            workspace_client = function.connection.workspace_client
+            workspace_host = workspace_client.config.host
+            connection_name = function.connection.name
+            mcp_url = f"{workspace_host}/api/2.0/mcp/external/{connection_name}"
+            logger.debug(f"Constructed MCP URL from connection: {mcp_url}")
+
+        async def _get_tools_with_connection():
+            """Get tools using DatabricksOAuthClientProvider."""
+            workspace_client = function.connection.workspace_client
+
+            async with streamablehttp_client(
+                mcp_url, auth=DatabricksOAuthClientProvider(workspace_client)
+            ) as (read_stream, write_stream, _):
+                async with ClientSession(read_stream, write_stream) as session:
+                    # Initialize and list tools
+                    await session.initialize()
+                    tools = await load_mcp_tools(session)
+                    return tools
 
-        response = {
-            "url": function.url,
-            "transport": function.transport,
-            "headers": headers,
-        }
-
-        return response
+        try:
+            langchain_tools = asyncio.run(_get_tools_with_connection())
+            logger.debug(
+                f"Retrieved {len(langchain_tools)} MCP tools via UC Connection"
+            )
 
-    # Get available tools from MCP server
-    async def _list_mcp_tools():
-        connection = _create_fresh_connection()
-        client = MultiServerMCPClient({function.name: connection})
+            # Wrap tools with human-in-the-loop if needed
+            wrapped_tools = [
+                as_human_in_the_loop(tool, function) for tool in langchain_tools
+            ]
+            return wrapped_tools
 
-        try:
-            async with client.session(function.name) as session:
-                return await session.list_tools()
         except Exception as e:
-            logger.error(f"Failed to list MCP tools: {e}")
-            return []
-
-    # Note: This still needs to run sync during tool creation/registration
-    # The actual tool execution will be async
-    try:
-        mcp_tools: list | ListToolsResult = asyncio.run(_list_mcp_tools())
-        if isinstance(mcp_tools, ListToolsResult):
-            mcp_tools = mcp_tools.tools
-
-        logger.debug(f"Retrieved {len(mcp_tools)} MCP tools")
-    except Exception as e:
-        logger.error(f"Failed to get tools from MCP server: {e}")
-        raise RuntimeError(
-            f"Failed to list MCP tools for function '{function.name}' with transport '{function.transport}' and URL '{function.url}': {e}"
-        )
-
-    # Create wrapper tools with fresh session per invocation
-    def _create_tool_wrapper(mcp_tool: Tool) -> RunnableLike:
-        @create_tool(
-            mcp_tool.name,
-            description=mcp_tool.description or f"MCP tool: {mcp_tool.name}",
-            args_schema=mcp_tool.inputSchema,
-        )
-        async def tool_wrapper(**kwargs):
-            """Execute MCP tool with fresh session and authentication."""
-            logger.debug(f"Invoking MCP tool {mcp_tool.name} with fresh session")
+            logger.error(f"Failed to get tools from MCP server via UC Connection: {e}")
+            raise RuntimeError(
+                f"Failed to list MCP tools for function '{function.name}' via UC Connection '{function.connection.name}': {e}"
+            )
+
+    else:
+        # Use direct MCP connection with MultiServerMCPClient
+        logger.debug("Using direct MCP connection with MultiServerMCPClient")
+
+        def _create_fresh_connection() -> dict[str, Any]:
+            """Create connection config with fresh authentication headers."""
+            logger.debug("Creating fresh connection...")
+
+            if function.transport == TransportType.STDIO:
+                return {
+                    "command": function.command,
+                    "args": function.args,
+                    "transport": function.transport,
+                }
+
+            # For HTTP transport, generate fresh headers
+            headers = function.headers.copy() if function.headers else {}
+
+            if "Authorization" not in headers:
+                logger.debug("Generating fresh authentication token for MCP function")
+
+                from dao_ai.config import value_of
+                from dao_ai.providers.databricks import DatabricksProvider
+
+                try:
+                    provider = DatabricksProvider(
+                        workspace_host=value_of(function.workspace_host),
+                        client_id=value_of(function.client_id),
+                        client_secret=value_of(function.client_secret),
+                        pat=value_of(function.pat),
+                    )
+                    headers["Authorization"] = f"Bearer {provider.create_token()}"
+                    logger.debug("Generated fresh authentication token")
+                except Exception as e:
+                    logger.error(f"Failed to create fresh token: {e}")
+            else:
+                logger.debug("Using existing authentication token")
 
+            return {
+                "url": function.url,
+                "transport": function.transport,
+                "headers": headers,
+            }
+
+        # Get available tools from MCP server
+        async def _list_mcp_tools():
             connection = _create_fresh_connection()
             client = MultiServerMCPClient({function.name: connection})
 
             try:
                 async with client.session(function.name) as session:
-                    return await session.call_tool(mcp_tool.name, kwargs)
+                    return await session.list_tools()
             except Exception as e:
-                logger.error(f"MCP tool {mcp_tool.name} failed: {e}")
-                raise
+                logger.error(f"Failed to list MCP tools: {e}")
+                return []
 
-        return as_human_in_the_loop(tool_wrapper, function)
+        # Note: This still needs to run sync during tool creation/registration
+        # The actual tool execution will be async
+        try:
+            mcp_tools: list[Tool] | ListToolsResult = asyncio.run(_list_mcp_tools())
+            if isinstance(mcp_tools, ListToolsResult):
+                mcp_tools = mcp_tools.tools
 
-    return [_create_tool_wrapper(tool) for tool in mcp_tools]
+            logger.debug(f"Retrieved {len(mcp_tools)} MCP tools")
+        except Exception as e:
+            logger.error(f"Failed to get tools from MCP server: {e}")
+            raise RuntimeError(
+                f"Failed to list MCP tools for function '{function.name}' with transport '{function.transport}' and URL '{function.url}': {e}"
+            )
+
+        # Create wrapper tools with fresh session per invocation
+        def _create_tool_wrapper(mcp_tool: Tool) -> RunnableLike:
+            @create_tool(
+                mcp_tool.name,
+                description=mcp_tool.description or f"MCP tool: {mcp_tool.name}",
+                args_schema=mcp_tool.inputSchema,
+            )
+            async def tool_wrapper(**kwargs):
+                """Execute MCP tool with fresh session and authentication."""
+                logger.debug(f"Invoking MCP tool {mcp_tool.name} with fresh session")
+
+                connection = _create_fresh_connection()
+                client = MultiServerMCPClient({function.name: connection})
+
+                try:
+                    async with client.session(function.name) as session:
+                        return await session.call_tool(mcp_tool.name, kwargs)
+                except Exception as e:
+                    logger.error(f"MCP tool {mcp_tool.name} failed: {e}")
+                    raise
+
+            return as_human_in_the_loop(tool_wrapper, function)
+
+        return [_create_tool_wrapper(tool) for tool in mcp_tools]

dao_ai/tools/slack.py

@@ -0,0 +1,136 @@
+from typing import Any, Callable, Optional
+
+from databricks.sdk.service.serving import ExternalFunctionRequestHttpMethod
+from langchain_core.tools import tool
+from loguru import logger
+from requests import Response
+
+from dao_ai.config import ConnectionModel
+
+
+def _find_channel_id_by_name(
+    connection: ConnectionModel, channel_name: str
+) -> Optional[str]:
+    """
+    Find a Slack channel ID by channel name using the conversations.list API.
+
+    Based on: https://docs.databricks.com/aws/en/generative-ai/agent-framework/slack-agent
+
+    Args:
+        connection: ConnectionModel with workspace_client
+        channel_name: Name of the Slack channel (with or without '#' prefix)
+
+    Returns:
+        Channel ID if found, None otherwise
+    """
+    # Remove '#' prefix if present
+    clean_name = channel_name.lstrip("#")
+
+    logger.debug(f"Looking up Slack channel ID for channel name: {clean_name}")
+
+    try:
+        # Call Slack API to list conversations
+        response: Response = connection.workspace_client.serving_endpoints.http_request(
+            conn=connection.name,
+            method=ExternalFunctionRequestHttpMethod.GET,
+            path="/api/conversations.list",
+        )
+
+        if response.status_code != 200:
+            logger.error(f"Failed to list Slack channels: {response.text}")
+            return None
+
+        # Parse response
+        data = response.json()
+
+        if not data.get("ok"):
+            logger.error(f"Slack API returned error: {data.get('error')}")
+            return None
+
+        # Search for channel by name
+        channels = data.get("channels", [])
+        for channel in channels:
+            if channel.get("name") == clean_name:
+                channel_id = channel.get("id")
+                logger.debug(
+                    f"Found channel ID '{channel_id}' for channel name '{clean_name}'"
+                )
+                return channel_id
+
+        logger.warning(f"Channel '{clean_name}' not found in Slack workspace")
+        return None
+
+    except Exception as e:
+        logger.error(f"Error looking up Slack channel: {e}")
+        return None
+
+
+def create_send_slack_message_tool(
+    connection: ConnectionModel | dict[str, Any],
+    channel_id: Optional[str] = None,
+    channel_name: Optional[str] = None,
+    name: Optional[str] = None,
+    description: Optional[str] = None,
+) -> Callable[[str], Any]:
+    """
+    Create a tool that sends a message to a Slack channel.
+
+    Args:
+        connection: Unity Catalog connection to Slack (ConnectionModel or dict)
+        channel_id: Slack channel ID (e.g., 'C1234567890'). If not provided, channel_name is used.
+        channel_name: Slack channel name (e.g., 'general' or '#general'). Used to lookup channel_id if not provided.
+        name: Custom tool name (default: 'send_slack_message')
+        description: Custom tool description
+
+    Returns:
+        A tool function that sends messages to the specified Slack channel
+
+    Based on: https://docs.databricks.com/aws/en/generative-ai/agent-framework/slack-agent
+    """
+    logger.debug("create_send_slack_message_tool")
+
+    # Validate inputs
+    if channel_id is None and channel_name is None:
+        raise ValueError("Either channel_id or channel_name must be provided")
+
+    # Convert connection dict to ConnectionModel if needed
+    if isinstance(connection, dict):
+        connection = ConnectionModel(**connection)
+
+    # Look up channel_id from channel_name if needed
+    if channel_id is None and channel_name is not None:
+        logger.debug(f"Looking up channel_id for channel_name: {channel_name}")
+        channel_id = _find_channel_id_by_name(connection, channel_name)
+        if channel_id is None:
+            raise ValueError(f"Could not find Slack channel with name '{channel_name}'")
+        logger.debug(
+            f"Resolved channel_name '{channel_name}' to channel_id '{channel_id}'"
+        )
+
+    if name is None:
+        name = "send_slack_message"
+
+    if description is None:
+        description = "Send a message to a Slack channel"
+
+    @tool(
+        name_or_callable=name,
+        description=description,
+    )
+    def send_slack_message(text: str) -> str:
+        response: Response = connection.workspace_client.serving_endpoints.http_request(
+            conn=connection.name,
+            method=ExternalFunctionRequestHttpMethod.POST,
+            path="/api/chat.postMessage",
+            json={"channel": channel_id, "text": text},
+        )
+
+        if response.status_code == 200:
+            return "Successful request sent to Slack: " + response.text
+        else:
+            return (
+                "Encountered failure when executing request. Message from Call: "
+                + response.text
+            )
+
+    return send_slack_message

dao_ai/utils.py

@@ -43,6 +43,7 @@ def get_installed_packages() -> dict[str, str]:
     packages: Sequence[str] = [
         f"databricks-agents=={version('databricks-agents')}",
         f"databricks-langchain=={version('databricks-langchain')}",
+        f"databricks-mcp=={version('databricks-mcp')}",
         f"databricks-sdk[openai]=={version('databricks-sdk')}",
         f"duckduckgo-search=={version('duckduckgo-search')}",
         f"langchain=={version('langchain')}",
@@ -56,11 +57,14 @@ def get_installed_packages() -> dict[str, str]:
         f"langgraph-swarm=={version('langgraph-swarm')}",
         f"langmem=={version('langmem')}",
         f"loguru=={version('loguru')}",
+        f"mcp=={version('mcp')}",
         f"mlflow=={version('mlflow')}",
+        f"nest-asyncio=={version('nest-asyncio')}",
         f"openevals=={version('openevals')}",
         f"openpyxl=={version('openpyxl')}",
         f"psycopg[binary,pool]=={version('psycopg')}",
         f"pydantic=={version('pydantic')}",
+        f"pyyaml=={version('pyyaml')}",
         f"unitycatalog-ai[databricks]=={version('unitycatalog-ai')}",
         f"unitycatalog-langchain[databricks]=={version('unitycatalog-langchain')}",
     ]

{dao_ai-0.0.22.dist-info → dao_ai-0.0.24.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dao-ai
-Version: 0.0.22
+Version: 0.0.24
 Summary: DAO AI: A modular, multi-agent orchestration framework for complex AI workflows. Supports agent handoff, tool integration, and dynamic configuration via YAML.
 Project-URL: Homepage, https://github.com/natefleming/dao-ai
 Project-URL: Documentation, https://natefleming.github.io/dao-ai
@@ -24,27 +24,28 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: System :: Distributed Computing
 Requires-Python: >=3.12
-Requires-Dist: databricks-agents>=1.6.1
-Requires-Dist: databricks-langchain>=0.8.0
+Requires-Dist: databricks-agents>=1.7.0
+Requires-Dist: databricks-langchain>=0.8.1
+Requires-Dist: databricks-mcp>=0.3.0
 Requires-Dist: databricks-sdk[openai]>=0.67.0
 Requires-Dist: duckduckgo-search>=8.0.2
 Requires-Dist: grandalf>=0.8
 Requires-Dist: langchain-mcp-adapters>=0.1.10
 Requires-Dist: langchain-tavily>=0.2.11
 Requires-Dist: langchain>=0.3.27
-Requires-Dist: langgraph-checkpoint-postgres>=2.0.23
+Requires-Dist: langgraph-checkpoint-postgres>=2.0.25
 Requires-Dist: langgraph-supervisor>=0.0.29
 Requires-Dist: langgraph-swarm>=0.0.14
-Requires-Dist: langgraph>=0.6.7
+Requires-Dist: langgraph>=0.6.10
 Requires-Dist: langmem>=0.0.29
 Requires-Dist: loguru>=0.7.3
-Requires-Dist: mcp>=1.14.1
+Requires-Dist: mcp>=1.17.0
 Requires-Dist: mlflow>=3.4.0
 Requires-Dist: nest-asyncio>=1.6.0
 Requires-Dist: openevals>=0.0.19
 Requires-Dist: openpyxl>=3.1.5
 Requires-Dist: psycopg[binary,pool]>=3.2.9
-Requires-Dist: pydantic>=2.11.3
+Requires-Dist: pydantic>=2.12.0
 Requires-Dist: python-dotenv>=1.1.0
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: rich>=14.0.0
@@ -653,7 +654,7 @@ test:
 #### 4. MCP (Model Context Protocol) Tools (`type: mcp`)
    MCP tools allow interaction with external services that implement the Model Context Protocol, supporting both HTTP and stdio transports.
 
-   **Configuration Example:**
+   **Configuration Example (Direct URL):**
    ```yaml
    tools:
      weather_tool_mcp:
@@ -664,8 +665,30 @@ test:
          transport: streamable_http
          url: http://localhost:8000/mcp
    ```
+   
+   **Configuration Example (Unity Catalog Connection):**
+   MCP tools can also use Unity Catalog Connections for secure, governed access with on-behalf-of-user capabilities. The connection provides OAuth authentication, while the URL specifies the endpoint:
+   ```yaml
+   resources:
+     connections:
+       github_connection:
+         name: github_u2m_connection  # UC Connection name
+   
+   tools:
+     github_mcp:
+       name: github_mcp
+       function:
+         type: mcp
+         name: github_mcp
+         transport: streamable_http
+         url: https://workspace.databricks.com/api/2.0/mcp/external/github_u2m_connection  # MCP endpoint URL
+         connection: *github_connection  # UC Connection provides OAuth authentication
+   ```
+   
    **Development:**
-   Ensure the MCP service is running and accessible at the specified URL or command. The framework will handle the MCP protocol communication automatically.
+   - **For direct URL connections**: Ensure the MCP service is running and accessible at the specified URL or command. Provide OAuth credentials (client_id, client_secret) or PAT for authentication.
+   - **For UC Connection**: URL is required to specify the endpoint. The connection provides OAuth authentication via the workspace client. Ensure the connection is configured in Unity Catalog with appropriate MCP scopes (`mcp.genie`, `mcp.functions`, `mcp.vectorsearch`, `mcp.external`).
+   - The framework will handle the MCP protocol communication automatically, including session management and authentication.
 
 ### Configuring New Agents
 

{dao_ai-0.0.22.dist-info → dao_ai-0.0.24.dist-info}/RECORD

@@ -3,16 +3,16 @@ dao_ai/agent_as_code.py,sha256=kPSeDz2-1jRaed1TMs4LA3VECoyqe9_Ed2beRLB9gXQ,472
 dao_ai/catalog.py,sha256=sPZpHTD3lPx4EZUtIWeQV7VQM89WJ6YH__wluk1v2lE,4947
 dao_ai/chat_models.py,sha256=uhwwOTeLyHWqoTTgHrs4n5iSyTwe4EQcLKnh3jRxPWI,8626
 dao_ai/cli.py,sha256=Aez2TQW3Q8Ho1IaIkRggt0NevDxAAVPjXkePC5GPJF0,20429
-dao_ai/config.py,sha256=Kh0oJwWr2dhqrOriOEgjMs2CGhOdMYh1hTGO7sAPdw8,55268
+dao_ai/config.py,sha256=j9SAdf7UHSoS2pLos-oypJNDPS48A2rRq55OEW1wsMI,56755
 dao_ai/graph.py,sha256=APYc2y3cig4P52X4sOHSFSZNK8j5EtEPJLFwWeJ3KQQ,7956
 dao_ai/guardrails.py,sha256=4TKArDONRy8RwHzOT1plZ1rhy3x9GF_aeGpPCRl6wYA,4016
 dao_ai/messages.py,sha256=xl_3-WcFqZKCFCiov8sZOPljTdM3gX3fCHhxq-xFg2U,7005
 dao_ai/models.py,sha256=8r8GIG3EGxtVyWsRNI56lVaBjiNrPkzh4HdwMZRq8iw,31689
 dao_ai/nodes.py,sha256=SSuFNTXOdFaKg_aX-yUkQO7fM9wvNGu14lPXKDapU1U,8461
-dao_ai/prompts.py,sha256=vpmIbWs_szXUgNNDs5Gh2LcxKZti5pHDKSfoClUcgX0,1289
+dao_ai/prompts.py,sha256=7Hcstmv514P0s9s-TVoIlbkDV2XXOphGCW6gcPeyUYE,1628
 dao_ai/state.py,sha256=_lF9krAYYjvFDMUwZzVKOn0ZnXKcOrbjWKdre0C5B54,1137
 dao_ai/types.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dao_ai/utils.py,sha256=A7BR28Rv7tH9B_lLVKlgBnWtcPeQ-Bafm2f57oTrUlQ,4337
+dao_ai/utils.py,sha256=yXgqHrYdO5qDxgxUs2G5XJeLFgwg8D0BIJvbFkqSbhs,4519
 dao_ai/vector_search.py,sha256=jlaFS_iizJ55wblgzZmswMM3UOL-qOp2BGJc0JqXYSg,2839
 dao_ai/hooks/__init__.py,sha256=LlHGIuiZt6vGW8K5AQo1XJEkBP5vDVtMhq0IdjcLrD4,417
 dao_ai/hooks/core.py,sha256=ZShHctUSoauhBgdf1cecy9-D7J6-sGn-pKjuRMumW5U,6663
@@ -22,19 +22,20 @@ dao_ai/memory/core.py,sha256=DnEjQO3S7hXr3CDDd7C2eE7fQUmcCS_8q9BXEgjPH3U,4271
 dao_ai/memory/postgres.py,sha256=vvI3osjx1EoU5GBA6SCUstTBKillcmLl12hVgDMjfJY,15346
 dao_ai/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dao_ai/providers/base.py,sha256=-fjKypCOk28h6vioPfMj9YZSw_3Kcbi2nMuAyY7vX9k,1383
-dao_ai/providers/databricks.py,sha256=CFZ2RojcTjiJ1aGwNI3_0qCGf339w2o5h9CRDKNesLs,39825
-dao_ai/tools/__init__.py,sha256=ye6MHaJY7tUnJ8336YJiLxuZr55zDPNdOw6gm7j5jlc,1103
+dao_ai/providers/databricks.py,sha256=1BPYQxi4-Z4I1ygZYlKV8ycdxZTtWNXplySToayHCEI,43096
+dao_ai/tools/__init__.py,sha256=G5-5Yi6zpQOH53b5IzLdtsC6g0Ep6leI5GxgxOmgw7Q,1203
 dao_ai/tools/agent.py,sha256=WbQnyziiT12TLMrA7xK0VuOU029tdmUBXbUl-R1VZ0Q,1886
 dao_ai/tools/core.py,sha256=Kei33S8vrmvPOAyrFNekaWmV2jqZ-IPS1QDSvU7RZF0,1984
 dao_ai/tools/genie.py,sha256=8HSOCzSg6PlBzBYXMmNfUnl-LO03p3Ki3fxLPm_dhPg,15051
 dao_ai/tools/human_in_the_loop.py,sha256=yk35MO9eNETnYFH-sqlgR-G24TrEgXpJlnZUustsLkI,3681
-dao_ai/tools/mcp.py,sha256=auEt_dwv4J26fr5AgLmwmnAsI894-cyuvkvjItzAUxs,4419
+dao_ai/tools/mcp.py,sha256=CYv59yn-LIY11atUgNtN2W6vR7C6Qyo7-rvPcVJnXVk,7461
 dao_ai/tools/python.py,sha256=XcQiTMshZyLUTVR5peB3vqsoUoAAy8gol9_pcrhddfI,1831
+dao_ai/tools/slack.py,sha256=SCvyVcD9Pv_XXPXePE_fSU1Pd8VLTEkKDLvoGTZWy2Y,4775
 dao_ai/tools/time.py,sha256=Y-23qdnNHzwjvnfkWvYsE7PoWS1hfeKy44tA7sCnNac,8759
 dao_ai/tools/unity_catalog.py,sha256=uX_h52BuBAr4c9UeqSMI7DNz3BPRLeai5tBVW4sJqRI,13113
 dao_ai/tools/vector_search.py,sha256=EDYQs51zIPaAP0ma1D81wJT77GQ-v-cjb2XrFVWfWdg,2621
-dao_ai-0.0.22.dist-info/METADATA,sha256=kqyr-YBFC_fs-PHknnvm4Ahhad8Pfac0gTb8vKydHMw,41380
-dao_ai-0.0.22.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dao_ai-0.0.22.dist-info/entry_points.txt,sha256=Xa-UFyc6gWGwMqMJOt06ZOog2vAfygV_DSwg1AiP46g,43
-dao_ai-0.0.22.dist-info/licenses/LICENSE,sha256=YZt3W32LtPYruuvHE9lGk2bw6ZPMMJD8yLrjgHybyz4,1069
-dao_ai-0.0.22.dist-info/RECORD,,
+dao_ai-0.0.24.dist-info/METADATA,sha256=69qYBqdZg8tZF1ni90RBrSG9OAmE4jXdf5lec6U0TL8,42639
+dao_ai-0.0.24.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dao_ai-0.0.24.dist-info/entry_points.txt,sha256=Xa-UFyc6gWGwMqMJOt06ZOog2vAfygV_DSwg1AiP46g,43
+dao_ai-0.0.24.dist-info/licenses/LICENSE,sha256=YZt3W32LtPYruuvHE9lGk2bw6ZPMMJD8yLrjgHybyz4,1069
+dao_ai-0.0.24.dist-info/RECORD,,