Upmerge from 1.16 into 1.17

daprdocs/content/en/concepts/dapr-services/scheduler.md

@@ -178,15 +178,15 @@ The Dapr CLI provides a command for exporting all Scheduler data to a specific b
 Use the `-k` flag when running in Kubernetes mode.
 
 ```shell
-dapr scheduler export --output-file scheduler-backup.db
-dapr scheduler export -k --output-file scheduler-backup.db
+dapr scheduler export -o scheduler-backup.bin
+dapr scheduler export -k -o scheduler-backup.bin
 ```
 
 To restore data from a backup file:
 
 ```shell
-dapr scheduler import --input-file scheduler-backup.db
-dapr scheduler import -k --input-file scheduler-backup.db
+dapr scheduler import -f scheduler-backup.bin
+dapr scheduler import -k -f scheduler-backup.bin
 ```
 
 ## Monitoring Scheduler's etcd Metrics

daprdocs/content/en/developing-ai/agent-integrations/langgraph/_index.md

@@ -0,0 +1,11 @@
+---
+type: docs
+title: "LangGraph"
+linkTitle: "LangGraph"
+weight: 25
+description: "Dapr first-class integrations with LangGraph Agents"
+---
+
+###  What is the Dapr LangGraph integration?
+
+Dapr provides LangGraph agents a first class integration to agent session management (checkpointers).

daprdocs/content/en/developing-ai/agent-integrations/langgraph/langgraph-agents-sessions.md

@@ -0,0 +1,149 @@
+---
+type: docs
+title: "Agent Sessions"
+linkTitle: "Agent Sessions"
+weight: 30
+description: "How to use Dapr reliably and securely manage LangGraph Agent Checkpointers"
+---
+
+## Overview
+
+The Dapr Python SDK provides integration with LangGraph Checkpointer using the `dapr-ext-langgraph` extension.
+
+## Getting Started
+
+Initialize Dapr locally to set up a self-hosted environment for development. This process fetches and installs the Dapr sidecar binaries, runs essential services as Docker containers, and prepares a default components folder for your application. For detailed steps, see the official [guide on initializing Dapr locally]({{% ref install-dapr-cli.md %}}).
+
+To initialize the Dapr control plane containers and create a default configuration file, run:
+
+```bash
+dapr init
+```
+
+Verify you have container instances with `daprio/dapr`, `openzipkin/zipkin`, and `redis` images running:
+
+```bash
+docker ps
+```
+
+### Install Python
+
+{{% alert title="Note" color="info" %}}
+Make sure you have Python already installed. `Python >=3.10`. For installation instructions, visit the official [Python installation guide](https://www.python.org/downloads/).
+{{% /alert %}}
+
+### Download Dependencies
+
+Download and install the Dapr LangGraph extension with:
+
+{{< tabpane text=true >}}
+
+{{% tab header="Stable" %}}
+
+```bash
+pip install dapr-ext-langgraph langchain_openai langchain_core langgraph langgraph-prebuilt
+```
+
+{{% /tab %}}
+
+{{% tab header="Development" %}}
+{{% alert title="Note" color="warning" %}}
+The development package will contain features and behavior that will be compatible with the pre-release version of the Dapr runtime. Make sure to uninstall any stable versions of the Python SDK extension before installing the `dapr-dev` package.
+{{% /alert %}}
+
+```bash
+pip install dapr-ext-langgraph-dev langchain_openai langchain_core langgraph langgraph-prebuilt
+```
+
+{{% /tab %}}
+
+{{< /tabpane >}}
+
+### Create a LangGraph Agent
+
+To let Dapr handle the agent memory, utilize the `DaprCheckpointer` as the checkpointer object when compiling the graph. Pass the checkpointer just like any other checkpointer provider:
+
+```python
+from dapr.ext.langgraph import DaprCheckpointer
+from langchain_openai import ChatOpenAI
+from langchain_core.messages import HumanMessage, SystemMessage
+from langgraph.graph import START, MessagesState, StateGraph
+from langgraph.prebuilt import ToolNode, tools_condition
+
+
+def add(a: int, b: int) -> int:
+    """Adds a and b.
+
+    Args:
+        a: first int
+        b: second int
+    """
+    return a + b
+
+tools = [add]
+llm = ChatOpenAI(model="gpt-4o")
+llm_with_tools = llm.bind_tools(tools)
+
+sys_msg = SystemMessage(
+    content='You are a helpful assistant tasked with performing arithmetic on a set of inputs.'
+)
+
+def assistant(state: MessagesState):
+    return {'messages': [llm_with_tools.invoke([sys_msg] + state['messages'])]}
+
+builder = StateGraph(MessagesState)
+builder.add_node('assistant', assistant)
+builder.add_node('tools', ToolNode(tools))
+builder.add_edge(START, 'assistant')
+builder.add_conditional_edges(
+    'assistant',
+    tools_condition,
+)
+builder.add_edge('tools', 'assistant')
+
+memory = DaprCheckpointer(store_name='statestore', key_prefix='dapr')
+react_graph_memory = builder.compile(checkpointer=memory)
+
+config = {'configurable': {'thread_id': '1'}}
+
+messages = [HumanMessage(content='Add 3 and 4.')]
+messages = react_graph_memory.invoke({'messages': messages}, config)
+for m in messages['messages']:
+    m.pretty_print()
+```
+
+### Set an OpenAI API key
+
+```bash
+export OPENAI_API_KEY=sk-...
+```
+
+### Create a Python venv
+
+```bash
+python -m venv .venv                                                                                                                                                                      
+source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+```
+
+## Create the database component
+
+The component file is how Dapr connects to your databae. The full list of supported databases can be found [here]({{% ref supported-state-stores %}}). Create a `components` directory and this file in it:
+
+```yaml
+apiVersion: dapr.io/v1alpha1
+kind: Component
+metadata:
+  name: statestore
+spec:
+  type: state.redis
+  version: v1
+  metadata:
+  - name: redisHost
+    value: localhost:6379
+  - name: redisPassword
+    value: ""
+```
+
+## Next Steps
+
+Now that you have a LangGraph agent using Dapr to manage the agent sessions, explore more you can do with the [State API]({{% ref "state-management-overview" %}}) and how to enable [resiliency policies]({{% ref resiliency-overview %}}) for enhanced reliability.

daprdocs/content/en/developing-ai/agent-integrations/openai-agents/_index.md

@@ -1,7 +1,7 @@
 ---
 type: docs
-title: "OpenAI Agents"
-linkTitle: "OpenAI Agents"
+title: "OpenAI"
+linkTitle: "OpenAI"
 weight: 25
 description: "Dapr first-class integrations for OpenAI Agents"
 ---

daprdocs/content/en/developing-ai/dapr-agents/_index.md

@@ -8,6 +8,8 @@ aliases:
   - /developing-applications/dapr-agents
 ---
 
+![Concepts Agents](/images/dapr-agents/agents-blue.png)
+
 ###  What is Dapr Agents?
 
 Dapr Agents is a Python framework for building LLM-powered autonomous agentic applications using Dapr's distributed systems capabilities. It provides tools for creating AI agents that can execute durable tasks, make decisions, and collaborate through workflows, while leveraging Dapr's state management, messaging, and observability features for reliable execution at scale.

daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-core-concepts.md

@@ -337,91 +337,79 @@ Workflows are structured processes where LLM agents and tools collaborate in pre
 This approach is particularly suitable for business-critical applications where you need both the intelligence of LLMs and the reliability of traditional software systems.
 
 ```python
-import dapr.ext.workflow as wf
-from dapr.ext.workflow import DaprWorkflowContext
-
-from dapr_agents.llm.dapr import DaprChatClient
-from dapr_agents.workflow.decorators import llm_activity
-
-runtime = wf.WorkflowRuntime()
-llm = DaprChatClient(component_name="openai")
+import time
 
+import dapr.ext.workflow as wf
 
-@runtime.workflow(name="task_chain_workflow")
-def task_chain_workflow(ctx: DaprWorkflowContext):
-    character = yield ctx.call_activity(get_character)
-    line = yield ctx.call_activity(get_line, input={"character": character})
-    return line
-
+wfr = wf.WorkflowRuntime()
 
-@runtime.activity(name="get_character")
-@llm_activity(
-    prompt="Pick a random character from The Lord of the Rings. Respond with the name only.",
-    llm=llm,
-)
-def get_character(ctx) -> str:
-    pass
+@wfr.workflow(name="support_workflow")
+def support_workflow(ctx: wf.DaprWorkflowContext, request: dict) -> str:
+    triage_result = yield ctx.call_child_workflow(
+        workflow="agent_workflow",
+        input={"task": f"Assist with the following support request:\n\n{request}"},
+        app_id="triage-agent",
+    )
+    if triage_result:
+        print("Triage result:", triage_result.get("content", ""), flush=True)
 
+    recommendation = yield ctx.call_child_workflow(
+        workflow="agent_workflow",
+        input={"task": triage_result.get("content", "")},
+        app_id="expert-agent",
+    )
+    if recommendation:
+        print("Recommendation:", recommendation.get("content", ""), flush=True)
 
-@runtime.activity(name="get_line")
-@llm_activity(
-    prompt="What is a famous line by {character}?",
-    llm=llm,
-)
-def get_line(ctx, character: str) -> str:
-    pass
+    return recommendation.get("content", "") if recommendation else ""
 
+wfr.start()
+time.sleep(5)
 
-runtime.start()
 client = wf.DaprWorkflowClient()
-instance_id = client.schedule_new_workflow(task_chain_workflow)
-state = client.wait_for_workflow_completion(instance_id)
-print(state.serialized_output)
-runtime.shutdown()
-```
-
-This workflow demonstrates sequential task execution where the output of one LLM-backed activity becomes the input for the next. The `@llm_activity` decorator wires prompts, formatting, and response handling so activities stay deterministic while still using model reasoning.
-
-Dapr Agents supports coordination of LLM interactions at different levels of granularity:
-
-### LLM Activities
-`@llm_activity` binds a workflow activity to a prompt, LLM client, and optional structured output. The decorated function body can stay empty because the decorator handles prompting, retries, and response parsing.
-
-```python
-llm = DaprChatClient(component_name="openai")
-
-@runtime.activity(name="generate_outline")
-@llm_activity(
-    prompt="Create a short outline about {topic}.",
-    llm=llm,
+request = {
+    "customer": "alice",
+    "issue": "Unable to access dashboard after recent update",
+}
+instance_id = client.schedule_new_workflow(
+    workflow=support_workflow,
+    input=request,
 )
-def generate_outline(ctx, topic: str) -> str:
-    pass
+client.wait_for_workflow_completion(instance_id, timeout_in_seconds=60)
+wfr.shutdown()
 ```
 
-LLM activities are perfect for lightweight reasoning steps, extraction tasks, or summarization stages that need deterministic workflow control with LLM flexibility.
-
-### Agent Activities
-`@agent_activity` lets workflows call fully-configured `Agent` instances (tools, memory, instructions) as activities. The workflow provides the inputs, and the decorator routes execution through the agent’s reasoning loop.
+Here the `call_child_workflow` is used to invoke the workflow of two Dapr Agents and pass output from one as input to the other. This requires the `DurableAgent` to run as:
 
 ```python
-planner = Agent(
-    name="PlannerAgent",
-    role="Trip planner",
-    instructions=["Create a concise 3-day plan for any city."],
-    llm=DaprChatClient(component_name="openai"),
-)
+from dapr_agents import DurableAgent
+from dapr_agents.agents.configs import AgentMemoryConfig
+from dapr_agents.llm.dapr import DaprChatClient
+from dapr_agents.memory import ConversationDaprStateMemory
+from dapr_agents.workflow.runners.agent import AgentRunner
 
-@runtime.activity(name="plan_outline")
-@agent_activity(agent=planner)
-def plan_outline(ctx, destination: str) -> dict:
-    pass
+expert_agent = DurableAgent(
+    name="expert_agent",
+    role="Technical Support Specialist",
+    goal="Provide recommendations based on customer context and issue.",
+    instructions=[
+        "Provide a clear, actionable recommendation to resolve the issue.",
+    ],
+    llm=DaprChatClient(component_name="llm-provider"),
+    memory=AgentMemoryConfig(
+        store=ConversationDaprStateMemory(
+            store_name="agent-memory",
+            session_id=f"expert-agent-session",
+        )
+    ),
+)
+runner = AgentRunner()
+try:
+    runner.serve(expert_agent, port=8001)
+finally:
+    runner.shutdown(expert_agent)
 ```
 
-Agent activities enable workflows to leverage specialized agents with their own tools, memory, and reasoning capabilities while maintaining the structured coordination benefits of workflow orchestration.
-
-> **Note:** Agent activities must use regular `Agent` instances, not `DurableAgent` instances, because workflows manage the execution context and durability through the Dapr workflow engine.
-
 ### Workflow Patterns
 
 Workflows enable the implementation of various agentic patterns through structured orchestration, including Prompt Chaining, Routing, Parallelization, Orchestrator-Workers, Evaluator-Optimizer, Human-in-the-loop, and others. For detailed implementations and examples of these patterns, see the [Patterns documentation]({{< ref dapr-agents-patterns.md >}}).

daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-patterns.md

@@ -436,6 +436,34 @@ The Durable Agent enables the concept of "headless agents" - autonomous systems
 
 These options make it easy to process requests asynchronously and integrate seamlessly into larger distributed systems.
 
+### Retry Policy
+
+The Durable Agent supports Dapr Workflow's `RetryPolicy` with the its `WorkflowRetryPolicy`:
+
+- `max_attempts`: max_attempts: Maximum number of retry attempts for workflow operations. Default is 1 (no retries). Set `DAPR_API_MAX_RETRIES` environment variable to override default.
+- `initial_backoff_seconds`: Initial backoff duration in seconds. Default is 5 seconds.
+- `max_backoff_seconds`: Maximum backoff duration in seconds. Default is 30 seconds.
+- `backoff_multiplier`: Backoff multiplier for exponential backoff. Default is 1.5.
+- `retry_timeout`: Total timeout for all retries in seconds.
+
+All of the fields are optional. It can be passed to the Durable Agent during instantiation:
+
+```python
+from dapr_agents.agents.configs import WorkflowRetryPolicy
+travel_planner = DurableAgent(
+    name="TravelBuddy",
+    ...
+    retry_policy=WorkflowRetryPolicy(
+        max_attempts=5,
+        initial_backoff_seconds=10,
+        max_backoff_seconds=60,
+        backoff_multiplier=2.0,
+        retry_timeout=300,
+    )
+    ...
+)
+```
+
 
 ## Choosing the Right Pattern
 

daprdocs/content/en/developing-ai/mcp/_index.md

@@ -0,0 +1,12 @@
+---
+type: docs
+title: "MCP"
+linkTitle: "MCP"
+weight: 25
+description: "Dapr helps developers run secure and reliable Model Context Protocol (MCP) servers"
+---
+
+###  What does Dapr do for MCP servers?
+
+Using Dapr, developers can interact securely with MCP servers and enable fine-grained ACLs with built-in tracing and metrics, as well as resiliency policies to handle situations where an MCP server might be down or unresponsive.
+