dao-ai 0.0.16__tar.gz → 0.0.17__tar.gz

{dao_ai-0.0.16 → dao_ai-0.0.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dao-ai
-Version: 0.0.16
+Version: 0.0.17
 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

dao_ai-0.0.17/config/examples/deep_research.yaml

@@ -0,0 +1,237 @@
+# yaml-language-server: $schema=../../schemas/model_config_schema.json
+
+variables:
+  tavily_search_key: &tavily_search_key                                                                                       
+    options:
+      - env: TAVILY_API_KEY                         
+      - scope: retail_consumer_goods                    
+        secret: TAVILY_API_KEY                      
+
+schemas:
+  executive_assistant_schema: &executive_assistant_schema
+    catalog_name: retail_consumer_goods                  
+    schema_name: store_ops                
+
+resources:
+  llms:
+
+    fast_llm: &fast_llm
+      name: databricks-meta-llama-3-1-8b-instruct 
+      temperature: 0.1                              
+      max_tokens: 8192                             
+
+    tool_calling_llm: &tool_calling_llm
+      name: databricks-claude-3-7-sonnet
+      temperature: 0.1
+      max_tokens: 8192
+      fallbacks:                                   
+        - databricks-meta-llama-3-3-70b-instruct
+
+    # LLM for complex reasoning tasks
+    reasoning_llm: &reasoning_llm
+      name: databricks-claude-3-7-sonnet
+      temperature: 0.1
+      max_tokens: 8192
+
+    deep_reasoning_llm: &deep_reasoning_llm
+      name: databricks-claude-sonnet-4
+      temperature: 0.1
+      max_tokens: 8192
+      fallbacks: 
+        - databricks-claude-3-7-sonnet
+
+    judge_llm: &judge_llm
+      name: databricks-claude-3-7-sonnet
+      temperature: 0.5                            
+      max_tokens: 8192
+
+    embedding_model: &embedding_model
+      name: databricks-gte-large-en              
+
+
+  tables:
+    employee_performance:
+      schema: *executive_assistant_schema                        
+      name: employee_performance                              
+    
+    products:
+      schema: *executive_assistant_schema
+      name: products
+
+    inventory: 
+      schema: *executive_assistant_schema
+      name: inventory
+
+    customers: 
+      schema: *executive_assistant_schema
+      name: customers
+
+    managers:
+      schema: *executive_assistant_schema
+      name: managers
+
+    employee_tasks: 
+      schema: *executive_assistant_schema
+      name: employee_tasks
+
+    appointments: 
+      schema: *executive_assistant_schema
+      name: appointments
+
+    evaluation: 
+      schema: *executive_assistant_schema
+      name: evaluation
+
+
+  functions:
+
+    find_inventory_by_sku: &find_inventory_by_sku
+      schema: *executive_assistant_schema
+      name: find_inventory_by_sku
+
+    find_inventory_by_upc: &find_inventory_by_upc
+      schema: *executive_assistant_schema
+      name: find_inventory_by_upc     
+    
+    find_product_by_sku: &find_product_by_sku
+      schema: *executive_assistant_schema
+      name: find_product_by_sku     
+
+    find_product_by_upc: &find_product_by_upc
+      schema: *executive_assistant_schema
+      name: find_product_by_upc     
+
+    find_store_by_number: &find_store_by_number
+      schema: *executive_assistant_schema
+      name: find_store_by_number     
+    
+    find_store_inventory_by_sku: &find_store_inventory_by_sku
+      schema: *executive_assistant_schema
+      name: find_store_inventory_by_sku     
+
+    find_store_inventory_by_upc: &find_store_inventory_by_upc
+      schema: *executive_assistant_schema
+      name: find_store_inventory_by_upc
+
+  genie_rooms:
+    executive_assistant_genie_room: &executive_assistant_genie_room
+      name: "Executive Assistant Genie Room"                       
+      description: "A room for Genie agents to interact" 
+      space_id: 01f05dd06c421ad6b522bf7a517cf6d2          
+
+
+tools:
+  executive_assistant_genie_tool: &executive_assistant_genie_tool
+    name: executive_assistant_genie_tool
+    function:
+      type: factory                                 
+      name: dao_ai.tools.create_genie_tool     
+      args:                                     
+        name: executive_assistant_genie_tool
+        description: Query the data warehouse for customer KPIs, business metrics, employee performance, inventory data, and other operational insights. Use this tool multiple times as needed to gather comprehensive data for executive-level analysis and recommendations.
+        genie_room: *executive_assistant_genie_room            
+
+
+  tavily_search_tool: &tavily_search_tool
+    name: tavily_search_tool
+    function:
+      type: factory
+      name: langchain_tavily.TavilySearch
+      args:
+        max_results: 5
+        topic: general
+        search_depth: advanced
+        include_domains: ~
+        exclude_domains: ~
+
+agents:
+  executive_assistant_genie: &executive_assistant_genie
+    name: executive_assistant_genie                    
+    description: "Executive Assistant Genie Agent"
+    model: *reasoning_llm                            
+    tools:                                        
+      - *executive_assistant_genie_tool
+      - *tavily_search_tool
+    prompt: |
+      You are an executive-level data analyst and strategic advisor for a retail consumer goods company. Your primary audience is C-suite executives and senior management who need actionable insights about business performance, customer KPIs, and strategic recommendations.
+
+      ## Your Core Responsibilities:
+      
+      ### 1. Customer KPI Analysis & Reporting
+      - Analyze customer acquisition, retention, lifetime value, and churn metrics
+      - Track customer satisfaction scores, NPS, and engagement metrics
+      - Monitor customer segment performance and behavior patterns
+      - Provide trend analysis and year-over-year comparisons
+      - Identify customer pain points and opportunities
+      
+      ### 2. Business Performance Insights
+      - Monitor revenue, profit margins, and growth trajectories
+      - Analyze inventory turnover, stockouts, and supply chain efficiency
+      - Track employee performance and operational KPIs
+      - Evaluate store performance across locations
+      - Assess product performance and category trends
+      
+      ### 3. Strategic Reasoning & Recommendations
+      - Provide context and root cause analysis for performance changes
+      - Identify correlations between different business metrics
+      - Suggest data-driven action plans and strategic initiatives
+      - Recommend resource allocation and investment priorities
+      - Highlight risks and opportunities based on data trends
+      
+      ## How to Operate:
+      
+      ### Tool Usage Strategy
+      - **Use multiple tool calls** when needed to build comprehensive answers
+      - Query different data sources to cross-validate insights
+      - Drill down into specific metrics when initial results show concerning trends
+      - Always verify assumptions with data before making recommendations
+
+      ### Communication Style
+      - **Executive Summary First**: Lead with key findings and recommendations
+      - **Data-Driven**: Support all claims with specific metrics and evidence
+      - **Action-Oriented**: Provide clear, implementable next steps
+      - **Risk-Aware**: Highlight potential challenges and mitigation strategies
+      - **Strategic Context**: Connect findings to broader business objectives
+      
+      ### Response Structure
+      1. **Executive Summary** (2-3 bullet points of key insights)
+      2. **Key Metrics & Analysis** (specific data points with context)
+      3. **Root Cause Analysis** (why trends are occurring)
+      4. **Strategic Recommendations** (actionable next steps)
+      5. **Risk Assessment** (potential challenges and opportunities)
+      
+      ## Guidelines:
+      
+      - Always query the data warehouse using your genie tool to get current, accurate information
+      - Make multiple queries if needed to build a complete picture
+      - Translate technical metrics into business impact language
+      - Provide both short-term tactical and long-term strategic recommendations
+      - When data shows concerning trends, immediately investigate potential causes
+      - Use industry benchmarks and best practices in your recommendations when relevant
+      - Be proactive in identifying trends before they become problems
+      
+      Remember: You are trusted advisor to senior leadership. Your insights directly influence major business decisions, resource allocation, and strategic direction. Ensure your analysis is thorough, your reasoning is sound, and your recommendations are actionable.
+
+
+app:
+  name: executive_assistant_agent                        
+  description: "An executive assistant application"
+  log_level: DEBUG                                  
+  registered_model:                                
+    schema: *executive_assistant_schema                        
+    name: executive_assistant_agent                          
+  endpoint_name: executive_assistant_agent    
+  environment_vars: 
+    TAVILY_API_KEY: "{{secrets/retail_consumer_goods/TAVILY_API_KEY}}" 
+  tags:                                            
+    business: rcg                                 
+    streaming: true                                
+  permissions:                                     
+    - principals: [users]                         
+      entitlements:
+        - CAN_QUERY                               
+  agents:                                        
+    - *executive_assistant_genie                                      
+  orchestration:                                  
+    swarm:                                    
+      model: *fast_llm                           

{dao_ai-0.0.16 → dao_ai-0.0.17}/config/examples/executive_assistant.yaml

@@ -34,8 +34,7 @@ resources:
       max_tokens: 8192
 
     deep_reasoning_llm: &deep_reasoning_llm
-      #name: databricks-claude-sonnet-4
-      name: databricks-meta-llama-3-3-70b-instruct
+      name: databricks-claude-sonnet-4
       temperature: 0.1
       max_tokens: 8192
       fallbacks: 
@@ -149,7 +148,7 @@ agents:
   executive_assistant_genie: &executive_assistant_genie
     name: executive_assistant_genie                    
     description: "Executive Assistant Genie Agent"
-    model: *deep_reasoning_llm                            
+    model: *reasoning_llm                            
     tools:                                        
       - *executive_assistant_genie_tool
       - *tavily_search_tool

{dao_ai-0.0.16 → dao_ai-0.0.17}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "dao-ai"
-version = "0.0.16"
+version = "0.0.17"
 description = "DAO AI: A modular, multi-agent orchestration framework for complex AI workflows. Supports agent handoff, tool integration, and dynamic configuration via YAML."
 readme = "README.md"
 license = { text = "MIT" }

{dao_ai-0.0.16 → dao_ai-0.0.17}/src/dao_ai/graph.py

@@ -221,7 +221,7 @@ def _create_swarm_graph(config: AppConfig) -> CompiledStateGraph:
 
     return swarm_node
 
-    #return workflow.compile(checkpointer=checkpointer, store=store)
+    # return workflow.compile(checkpointer=checkpointer, store=store)
 
 
 def create_dao_ai_graph(config: AppConfig) -> CompiledStateGraph:

{dao_ai-0.0.16 → dao_ai-0.0.17}/src/dao_ai/models.py

@@ -65,9 +65,19 @@ class LanggraphChatModel(ChatModel):
         context: Context = self._convert_to_context(params)
         custom_inputs: dict[str, Any] = {"configurable": context.model_dump()}
 
-        response: dict[str, Sequence[BaseMessage]] = self.graph.invoke(
-            request, context=context, config=custom_inputs
+        # Use async ainvoke internally for parallel execution
+        import asyncio
+
+        async def _async_invoke():
+            return await self.graph.ainvoke(
+                request, context=context, config=custom_inputs
+            )
+
+        loop = asyncio.get_event_loop()
+        response: dict[str, Sequence[BaseMessage]] = loop.run_until_complete(
+            _async_invoke()
         )
+
         logger.trace(f"response: {response}")
 
         last_message: BaseMessage = response["messages"][-1]
@@ -114,33 +124,51 @@ class LanggraphChatModel(ChatModel):
         context: Context = self._convert_to_context(params)
         custom_inputs: dict[str, Any] = {"configurable": context.model_dump()}
 
-        for nodes, stream_mode, messages_batch in self.graph.stream(
-            request,
-            context=context,
-            config=custom_inputs,
-            stream_mode=["messages", "custom"],
-            subgraphs=True,
-        ):
-            nodes: tuple[str, ...]
-            stream_mode: str
-            messages_batch: Sequence[BaseMessage]
-            logger.trace(
-                f"nodes: {nodes}, stream_mode: {stream_mode}, messages: {messages_batch}"
-            )
-            for message in messages_batch:
-                if (
-                    isinstance(
-                        message,
-                        (
-                            AIMessageChunk,
-                            AIMessage,
-                        ),
-                    )
-                    and message.content
-                    and "summarization" not in nodes
-                ):
-                    content = message.content
-                    yield self._create_chat_completion_chunk(content)
+        # Use async astream internally for parallel execution
+        import asyncio
+
+        async def _async_stream():
+            async for nodes, stream_mode, messages_batch in self.graph.astream(
+                request,
+                context=context,
+                config=custom_inputs,
+                stream_mode=["messages", "custom"],
+                subgraphs=True,
+            ):
+                nodes: tuple[str, ...]
+                stream_mode: str
+                messages_batch: Sequence[BaseMessage]
+                logger.trace(
+                    f"nodes: {nodes}, stream_mode: {stream_mode}, messages: {messages_batch}"
+                )
+                for message in messages_batch:
+                    if (
+                        isinstance(
+                            message,
+                            (
+                                AIMessageChunk,
+                                AIMessage,
+                            ),
+                        )
+                        and message.content
+                        and "summarization" not in nodes
+                    ):
+                        content = message.content
+                        yield self._create_chat_completion_chunk(content)
+
+        # Convert async generator to sync generator
+        loop = asyncio.get_event_loop()
+        async_gen = _async_stream()
+
+        try:
+            while True:
+                try:
+                    item = loop.run_until_complete(async_gen.__anext__())
+                    yield item
+                except StopAsyncIteration:
+                    break
+        finally:
+            loop.run_until_complete(async_gen.aclose())
 
     def _create_chat_completion_chunk(self, content: str) -> ChatCompletionChunk:
         return ChatCompletionChunk(
@@ -178,9 +206,18 @@ def _process_langchain_messages(
     messages: Sequence[BaseMessage],
     custom_inputs: Optional[dict[str, Any]] = None,
 ) -> dict[str, Any] | Any:
+    """Process LangChain messages using async LangGraph calls internally."""
+    import asyncio
+
     if isinstance(app, LanggraphChatModel):
         app = app.graph
-    return app.invoke({"messages": messages}, config=custom_inputs)
+
+    # Use async ainvoke internally for parallel execution
+    async def _async_invoke():
+        return await app.ainvoke({"messages": messages}, config=custom_inputs)
+
+    loop = asyncio.get_event_loop()
+    return loop.run_until_complete(_async_invoke())
 
 
 def _process_langchain_messages_stream(
@@ -188,6 +225,9 @@ def _process_langchain_messages_stream(
     messages: Sequence[BaseMessage],
     custom_inputs: Optional[dict[str, Any]] = None,
 ) -> Generator[AIMessageChunk, None, None]:
+    """Process LangChain messages in streaming mode using async LangGraph calls internally."""
+    import asyncio
+
     if isinstance(app, LanggraphChatModel):
         app = app.graph
 
@@ -196,32 +236,48 @@ def _process_langchain_messages_stream(
     custom_inputs = custom_inputs.get("configurable", custom_inputs or {})
     context: Context = Context(**custom_inputs)
 
-    for nodes, stream_mode, messages in app.stream(
-        {"messages": messages},
-        context=context,
-        config=custom_inputs,
-        stream_mode=["messages", "custom"],
-        subgraphs=True,
-    ):
-        nodes: tuple[str, ...]
-        stream_mode: str
-        messages: Sequence[BaseMessage]
-        logger.trace(
-            f"nodes: {nodes}, stream_mode: {stream_mode}, messages: {messages}"
-        )
-        for message in messages:
-            if (
-                isinstance(
-                    message,
-                    (
-                        AIMessageChunk,
-                        AIMessage,
-                    ),
-                )
-                and message.content
-                and "summarization" not in nodes
-            ):
-                yield message
+    # Use async astream internally for parallel execution
+    async def _async_stream():
+        async for nodes, stream_mode, stream_messages in app.astream(
+            {"messages": messages},
+            context=context,
+            config=custom_inputs,
+            stream_mode=["messages", "custom"],
+            subgraphs=True,
+        ):
+            nodes: tuple[str, ...]
+            stream_mode: str
+            stream_messages: Sequence[BaseMessage]
+            logger.trace(
+                f"nodes: {nodes}, stream_mode: {stream_mode}, messages: {stream_messages}"
+            )
+            for message in stream_messages:
+                if (
+                    isinstance(
+                        message,
+                        (
+                            AIMessageChunk,
+                            AIMessage,
+                        ),
+                    )
+                    and message.content
+                    and "summarization" not in nodes
+                ):
+                    yield message
+
+    # Convert async generator to sync generator
+    loop = asyncio.get_event_loop()
+    async_gen = _async_stream()
+
+    try:
+        while True:
+            try:
+                item = loop.run_until_complete(async_gen.__anext__())
+                yield item
+            except StopAsyncIteration:
+                break
+    finally:
+        loop.run_until_complete(async_gen.aclose())
 
 
 def _process_mlflow_messages(
@@ -272,7 +328,7 @@ def process_messages_stream(
     Process messages through a ChatAgent in streaming mode.
 
     Utility function that normalizes message input formats and
-    streams the agent's responses as they're generated.
+    streams the agent's responses as they're generated using async LangGraph calls internally.
 
     Args:
         app: The ChatAgent to process messages with
@@ -302,7 +358,7 @@ def process_messages(
     Process messages through a ChatAgent in batch mode.
 
     Utility function that normalizes message input formats and
-    returns the complete response from the agent.
+    returns the complete response from the agent using async LangGraph calls internally.
 
     Args:
         app: The ChatAgent to process messages with

{dao_ai-0.0.16 → dao_ai-0.0.17}/src/dao_ai/nodes.py

@@ -69,7 +69,7 @@ def summarization_node(app_model: AppModel) -> RunnableLike:
 
 
 def call_agent_with_summarized_messages(agent: CompiledStateGraph) -> RunnableLike:
-    def call_agent(state: SharedState, runtime: Runtime[Context]) -> SharedState:
+    async def call_agent(state: SharedState, runtime: Runtime[Context]) -> SharedState:
         logger.debug(f"Calling agent {agent.name} with summarized messages")
 
         # Get the summarized messages from the summarization node
@@ -81,7 +81,9 @@ def call_agent_with_summarized_messages(agent: CompiledStateGraph) -> RunnableLi
             "messages": messages,
         }
 
-        response: dict[str, Any] = agent.invoke(input=input, context=runtime.context)
+        response: dict[str, Any] = await agent.ainvoke(
+            input=input, context=runtime.context
+        )
         response_messages = response.get("messages", [])
         logger.debug(f"Agent returned {len(response_messages)} messages")
 
@@ -193,7 +195,9 @@ def message_hook_node(config: AppConfig) -> RunnableLike:
     message_hooks: Sequence[Callable[..., Any]] = create_hooks(config.app.message_hooks)
 
     @mlflow.trace()
-    def message_hook(state: IncomingState, runtime: Runtime[Context]) -> SharedState:
+    async def message_hook(
+        state: IncomingState, runtime: Runtime[Context]
+    ) -> SharedState:
         logger.debug("Running message validation")
         response: dict[str, Any] = {"is_valid": True, "message_error": None}
 

{dao_ai-0.0.16 → dao_ai-0.0.17}/src/dao_ai/tools/agent.py

@@ -40,16 +40,16 @@ def create_agent_endpoint_tool(
 
     doc: str = description + "\n" + doc_signature
 
-    def agent_endpoint(prompt: str) -> AIMessage:
+    async def agent_endpoint(prompt: str) -> AIMessage:
         model: LanguageModelLike = llm.as_chat_model()
         messages: Sequence[BaseMessage] = [HumanMessage(content=prompt)]
-        response: AIMessage = model.invoke(messages)
+        response: AIMessage = await model.ainvoke(messages)
         return response
 
     name: str = name if name else agent_endpoint.__name__
 
     structured_tool: StructuredTool = StructuredTool.from_function(
-        func=agent_endpoint, name=name, description=doc, parse_docstring=False
+        coroutine=agent_endpoint, name=name, description=doc, parse_docstring=False
     )
 
     return structured_tool

{dao_ai-0.0.16 → dao_ai-0.0.17}/src/dao_ai/tools/genie.py

@@ -62,14 +62,16 @@ def create_genie_tool(
 
     doc: str = description + "\n" + doc_signature
 
-    def genie_tool(question: str) -> GenieResponse:
+    async def genie_tool(question: str) -> GenieResponse:
+        # Use sync API for now since Genie doesn't support async yet
+        # Can be easily updated to await when Genie gets async support
         response: GenieResponse = genie.ask_question(question)
         return response
 
     name: str = name if name else genie_tool.__name__
 
     structured_tool: StructuredTool = StructuredTool.from_function(
-        func=genie_tool, name=name, description=doc, parse_docstring=False
+        coroutine=genie_tool, name=name, description=doc, parse_docstring=False
     )
 
     return structured_tool

{dao_ai-0.0.16 → dao_ai-0.0.17}/src/dao_ai/tools/human_in_the_loop.py

@@ -50,7 +50,7 @@ def add_human_in_the_loop(
     logger.debug(f"Wrapping tool {tool} with human-in-the-loop functionality")
 
     @create_tool(tool.name, description=tool.description, args_schema=tool.args_schema)
-    def call_tool_with_interrupt(config: RunnableConfig, **tool_input) -> Any:
+    async def call_tool_with_interrupt(config: RunnableConfig, **tool_input) -> Any:
         logger.debug(f"call_tool_with_interrupt: {tool.name} with input: {tool_input}")
         request: HumanInterrupt = {
             "action_request": {
@@ -66,10 +66,10 @@ def add_human_in_the_loop(
         logger.debug(f"Human interrupt response: {response}")
 
         if response["type"] == "accept":
-            tool_response = tool.invoke(tool_input, config=config)
+            tool_response = await tool.ainvoke(tool_input, config=config)
         elif response["type"] == "edit":
             tool_input = response["args"]["args"]
-            tool_response = tool.invoke(tool_input, config=config)
+            tool_response = await tool.ainvoke(tool_input, config=config)
         elif response["type"] == "response":
             user_feedback = response["args"]
             tool_response = user_feedback

{dao_ai-0.0.16 → dao_ai-0.0.17}/src/dao_ai/tools/mcp.py

@@ -77,6 +77,8 @@ def create_mcp_tools(
             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):
@@ -96,22 +98,19 @@ def create_mcp_tools(
             description=mcp_tool.description or f"MCP tool: {mcp_tool.name}",
             args_schema=mcp_tool.inputSchema,
         )
-        def tool_wrapper(**kwargs):
+        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")
 
-            async def _invoke():
-                connection = _create_fresh_connection()
-                client = MultiServerMCPClient({function.name: connection})
+            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 asyncio.run(_invoke())
+            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)