diff --git a/daprdocs/content/en/concepts/dapr-services/scheduler.md b/daprdocs/content/en/concepts/dapr-services/scheduler.md index f4fa6f02525..1a21e595dec 100644 --- a/daprdocs/content/en/concepts/dapr-services/scheduler.md +++ b/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 diff --git a/daprdocs/content/en/developing-ai/agent-integrations/langgraph/_index.md b/daprdocs/content/en/developing-ai/agent-integrations/langgraph/_index.md new file mode 100644 index 00000000000..c427457c95f --- /dev/null +++ b/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). diff --git a/daprdocs/content/en/developing-ai/agent-integrations/langgraph/langgraph-agents-sessions.md b/daprdocs/content/en/developing-ai/agent-integrations/langgraph/langgraph-agents-sessions.md new file mode 100644 index 00000000000..aa78693b707 --- /dev/null +++ b/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. diff --git a/daprdocs/content/en/developing-ai/agent-integrations/openai-agents/_index.md b/daprdocs/content/en/developing-ai/agent-integrations/openai-agents/_index.md index 83d119d11d3..85fd5e20c5e 100644 --- a/daprdocs/content/en/developing-ai/agent-integrations/openai-agents/_index.md +++ b/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" --- diff --git a/daprdocs/content/en/developing-ai/dapr-agents/_index.md b/daprdocs/content/en/developing-ai/dapr-agents/_index.md index 4300c2edfc5..28c123a407c 100644 --- a/daprdocs/content/en/developing-ai/dapr-agents/_index.md +++ b/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. diff --git a/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-core-concepts.md b/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-core-concepts.md index d960efea055..54d0f60b099 100644 --- a/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-core-concepts.md +++ b/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 >}}). diff --git a/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-patterns.md b/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-patterns.md index fa6eda426d6..e3b2e46f58f 100644 --- a/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-patterns.md +++ b/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 diff --git a/daprdocs/content/en/developing-ai/mcp/_index.md b/daprdocs/content/en/developing-ai/mcp/_index.md new file mode 100644 index 00000000000..013fc43339d --- /dev/null +++ b/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. + \ No newline at end of file diff --git a/daprdocs/content/en/developing-ai/mcp/mcp-authentication.md b/daprdocs/content/en/developing-ai/mcp/mcp-authentication.md new file mode 100644 index 00000000000..5981127f6ce --- /dev/null +++ b/daprdocs/content/en/developing-ai/mcp/mcp-authentication.md @@ -0,0 +1,204 @@ +--- +type: docs +title: "Authenticating an MCP server" +linkTitle: "Getting Started" +weight: 20 +description: "How to enable MCP client-side and server-side authentication" +--- + +## Overview + +The [MCP specification](https://modelcontextprotocol.io/specification/) does not mandate any form of authentication between an MCP client and server. The security model is left to the user to plan and implement. This creates a maintenance burden on developers and opens up MCP servers to various attack surfaces. + +While MCP servers lack identity, OAuth2 is a well established standard that can be used to properly authenticate MCP clients to MCP servers. + +OAuth2 becomes essential when MCP servers are: + +* Multi-tenant +* Remote +* Cloud-hosted +* Connected to confidential systems +* Performing privileged actions on behalf of a user +* Exposing tools that must be permission-gated + +Dapr enables OAuth2 authentication between MCP clients and servers using [middleware]({{% ref "middleware" %}}) components. + +## Types of authentication + +Dapr supports two critical authentication mechanisms for production grade deployments of MCP servers - Client-side and Server-side. + +### Client-side Authentication + +The client initiates OAuth2 to obtain an access token and includes it when connecting to the MCP server. +This proves the user’s identity and permissions and is required for remote, sensitive, or multi-tenant MCP servers. +It ensures the server can trust who is calling and what scopes the client is allowed to use. + +### Server-side Authentication + +The server validates the client’s token or, if missing or insufficient, triggers an OAuth2 login or scope upgrade. +This is needed for cloud-hosted or shared MCP servers, tenant-aware systems, and integrations that require user-specific authorization. +It enforces access control, isolates users, and protects privileged tools and data. + +## How to enable Client-side Authentication + +### Define the MCP Server as an HTTPEndpoint + +Dapr allows developers and operators to model remote HTTP services as resources that can be governed and invoked using the Dapr [Service Invocation API]({{% ref "service-invocation-overview" %}}). +Create this `HTTPEndpoint` resource to represent the MCP server: + +```yaml +apiVersion: dapr.io/v1alpha1 +kind: HTTPEndpoint +metadata: + name: "mcp-server" +spec: + baseUrl: https://my-mcp-server:443 + headers: + - name: "Accept" + value: "text/event-stream" +``` + +### Define the OAuth2 middleware and configuration components + +The following middleware component defines the connection to the OAuth2 provider: + +```yaml +apiVersion: dapr.io/v1alpha1 +kind: Component +metadata: + name: oauth2 +spec: + type: middleware.http.oauth2 + version: v1 + metadata: + - name: clientId + value: "" + - name: clientSecret + value: "" + - name: authURL + value: "" + - name: tokenURL + value: "" + - name: scopes + value: "" +``` + +Next, create the configuration resource which tells Dapr to use the OAuth2 middleware: + +```yaml +piVersion: dapr.io/v1alpha1 +kind: Configuration +metadata: + name: auth +spec: + tracing: + samplingRate: "1" + httpPipeline: + handlers: + - name: oauth2 # reference the oauth component here + type: middleware.http.oauth2 +``` + +{{% alert title="Note" color="primary" %}} +Visit [this link]({{% ref "component-secrets.md" %}}) to read on how to provide secrets to Dapr components +{{% /alert %}} + +### Call the MCP server using an MCP client + +Copy the following code to a file named `mcpclient.py`: + +```python +import asyncio +from mcp import ClientSession +from mcp.transport.http import HttpClientTransport + +async def main(): + # Default address of the Dapr process. Use an environment variable in production + server_url = "http://localhost:3500/" + + # Create an HTTP/SSE transport with a header to target our HTTPEndpoint defined above + transport = HttpClientTransport( + url=server_url, + headers={ + "dapr-app-id": "mcp-server", + } + event_headers={ + "Accept": "text/event-stream", + }, + ) + + # Create an MCP session bound to the transport + async with ClientSession(transport) as session: + await session.initialize() + + tools = await session.call("tools/list") + print("Server Tools:", tools)) + + await session.shutdown() + +if __name__ == "__main__": + asyncio.run(main()) +``` + +### Run the MCP client with Dapr + +Put the YAML files above into a `components` directory and run Dapr: + +```bash +dapr run --app-id mcpclient --resources-path ./components --dapr-http-port 3500 --config ./config.yaml -- python mcpclient.py +``` + +The MCP client causes Dapr to start an OAuth2 pipeline before connecting to the MCP server. + +## How to enable Server-side Authentication + +### Define the OAuth2 middleware and configuration components + +Define a middleware component the same as the client example. + +```yaml +apiVersion: dapr.io/v1alpha1 +kind: Component +metadata: + name: oauth2 +spec: + type: middleware.http.oauth2 + version: v1 + metadata: + - name: clientId + value: "" + - name: clientSecret + value: "" + - name: authURL + value: "" + - name: tokenURL + value: "" + - name: scopes + value: "" +``` + +Next, create the configuration component, with the modification of an `appHttpPipeline` field. This tells Dapr to apply the middleware for incoming calls. + +```yaml +piVersion: dapr.io/v1alpha1 +kind: Configuration +metadata: + name: auth +spec: + tracing: + samplingRate: "1" + appHttpPipeline: + handlers: + - name: oauth2 # reference the oauth component here + type: middleware.http.oauth2 +``` + +### Run the MCP server with Dapr + +Put the YAML files above in `components` directory and run Dapr: + +```bash +dapr run --app-id mcpclient --resources-path ./components --dapr-http-port 3500 --config ./config.yaml -- python mcpserver.py +``` + +Dapr will start an OAuth2 pipeline when a request for the MCP server arrives. diff --git a/daprdocs/content/en/developing-applications/building-blocks/actors/actors-timers-reminders.md b/daprdocs/content/en/developing-applications/building-blocks/actors/actors-timers-reminders.md index c95434b874a..fdf5a5e8bfe 100644 --- a/daprdocs/content/en/developing-applications/building-blocks/actors/actors-timers-reminders.md +++ b/daprdocs/content/en/developing-applications/building-blocks/actors/actors-timers-reminders.md @@ -185,6 +185,40 @@ Delete all reminders for a given actor type: dapr scheduler delete-all actor/MyActorType ``` +## Managing reminders with the CLI + +Actor reminders are persisted in the Scheduler. +You can manage them with the dapr scheduler CLI commands. + +#### List actor reminders + +```bash +dapr scheduler list --filter actor +NAME BEGIN COUNT LAST TRIGGER +actor/MyActorType/actorid1/test1 -3.89s 1 2025-10-03T16:58:55Z +actor/MyActorType/actorid2/test2 -3.89s 1 2025-10-03T16:58:55Z +``` + +Get reminder details + +```bash +dapr scheduler get actor/MyActorType/actorid1/test1 -o yaml +``` + +#### Delete reminders + +Delete a single reminder: + +```bash +dapr scheduler delete actor/MyActorType/actorid1/test1 +``` + +Delete all reminders for a given actor type: + +```bash +dapr scheduler delete-all actor/MyActorType +``` + Delete all reminders for a specific actor instance: ```bash diff --git a/daprdocs/content/en/operations/hosting/kubernetes/kubernetes-production.md b/daprdocs/content/en/operations/hosting/kubernetes/kubernetes-production.md index c4f4b88e2a0..c2a29e00169 100644 --- a/daprdocs/content/en/operations/hosting/kubernetes/kubernetes-production.md +++ b/daprdocs/content/en/operations/hosting/kubernetes/kubernetes-production.md @@ -310,7 +310,7 @@ It's recommended that you consider deploying your apps with `automountServiceAcc Thus, Dapr does not set `automountServiceAccountToken: false` automatically for you. However, in all situations where the Service Account is not required by your solution, it's recommended that you set this option in the pods spec. {{% alert title="Note" color="primary" %}} -Initializing Dapr components using [component secrets]({{% ref "component-secrets.md" %}}) stored as Kubernetes secrets does **not** require a Service Account token, so you can still set `automountServiceAccountToken: false` in this case. Only calling the Kubernetes secret store at runtime, using the [Secrets management]({{% ref "secrets-overview.md" %}}) building block, is impacted. +Initializing Dapr components using [component secrets]({{% ref "component-secrets.md" %}}) stored as Kubernetes secrets does **not** require your pod to have a Service Account token; the Dapr Operator resolves `secretKeyRef` at injection time. To run with `automountServiceAccountToken: false`, disable the sidecar's built-in Kubernetes secret store with the annotation `dapr.io/disable-builtin-k8s-secret-store: "true"`. Keep the secret store enabled (and mount a token) only if your app uses the runtime [Secrets management]({{% ref "secrets-overview.md" %}}) building block. {{% /alert %}} ## Tracing and metrics configuration diff --git a/daprdocs/content/en/operations/support/support-release-policy.md b/daprdocs/content/en/operations/support/support-release-policy.md index aae6a2f89ce..fd48b918c8f 100644 --- a/daprdocs/content/en/operations/support/support-release-policy.md +++ b/daprdocs/content/en/operations/support/support-release-policy.md @@ -45,6 +45,10 @@ The table below shows the versions of Dapr releases that have been tested togeth | Release date | Runtime | CLI | SDKs | Dashboard | Status | Release notes | |--------------------|:--------:|:--------|---------|---------|---------|------------| +| Feb 12th 2026 | 1.16.9
| 1.16.5 | Java 1.16.0
Go 1.13.0
PHP 1.2.0
Python 1.16.0
.NET 1.16.0
JS 3.6.0
Rust 0.17.0 | 0.15.0 | Supported (current) | [v1.16.9 release notes](https://github.com/dapr/dapr/releases/tag/v1.16.9) | +| Jan 26th 2026 | 1.16.8
| 1.16.5 | Java 1.16.0
Go 1.13.0
PHP 1.2.0
Python 1.16.0
.NET 1.16.0
JS 3.6.0
Rust 0.17.0 | 0.15.0 | Supported (current) | [v1.16.8 release notes](https://github.com/dapr/dapr/releases/tag/v1.16.8) | +| Jan 20th 2026 | 1.16.7
| 1.16.5 | Java 1.16.0
Go 1.13.0
PHP 1.2.0
Python 1.16.0
.NET 1.16.0
JS 3.6.0
Rust 0.17.0 | 0.15.0 | Supported (current) | [v1.16.7 release notes](https://github.com/dapr/dapr/releases/tag/v1.16.7) | +| Jan 20th 2026 | 1.16.7
| 1.16.5 | Java 1.16.0
Go 1.13.0
PHP 1.2.0
Python 1.16.0
.NET 1.16.0
JS 3.6.0
Rust 0.17.0 | 0.15.0 | Supported (current) | [v1.16.7 release notes](https://github.com/dapr/dapr/releases/tag/v1.16.7) | | Jan 9th 2026 | 1.16.6
| 1.16.5 | Java 1.16.0
Go 1.13.0
PHP 1.2.0
Python 1.16.0
.NET 1.16.0
JS 3.6.0
Rust 0.17.0 | 0.15.0 | Supported (current) | [v1.16.6 release notes](https://github.com/dapr/dapr/releases/tag/v1.16.6) | | Dec 19th 2025 | 1.16.5
| 1.16.5 | Java 1.16.0
Go 1.13.0
PHP 1.2.0
Python 1.16.0
.NET 1.16.0
JS 3.6.0
Rust 0.17.0 | 0.15.0 | Supported (current) | [v1.16.5 release notes](https://github.com/dapr/dapr/releases/tag/v1.16.5) | | Dec 8th 2025 | 1.16.4
| 1.16.5 | Java 1.16.0
Go 1.13.0
PHP 1.2.0
Python 1.16.0
.NET 1.16.0
JS 3.6.0
Rust 0.17.0 | 0.15.0 | Supported (current) | [v1.16.4 release notes](https://github.com/dapr/dapr/releases/tag/v1.16.4) | diff --git a/daprdocs/content/en/reference/components-reference/supported-pubsub/setup-apache-kafka.md b/daprdocs/content/en/reference/components-reference/supported-pubsub/setup-apache-kafka.md index bd57f2eaef3..f771c0ac763 100644 --- a/daprdocs/content/en/reference/components-reference/supported-pubsub/setup-apache-kafka.md +++ b/daprdocs/content/en/reference/components-reference/supported-pubsub/setup-apache-kafka.md @@ -102,9 +102,9 @@ spec: | clientCert | N | Client certificate, required for `authType` `mtls`. Can be `secretKeyRef` to use a secret reference | `"-----BEGIN CERTIFICATE-----\n\n-----END CERTIFICATE-----"` | clientKey | N | Client key, required for `authType` `mtls` Can be `secretKeyRef` to use a secret reference | `"-----BEGIN RSA PRIVATE KEY-----\n\n-----END RSA PRIVATE KEY-----"` | skipVerify | N | Skip TLS verification, this is not recommended for use in production. Defaults to `"false"` | `"true"`, `"false"` | -| disableTls | N | Disable TLS for transport security. To disable, you're not required to set value to `"true"`. This is not recommended for use in production. Defaults to `"false"`. | `"true"`, `"false"` | -| oidcTokenEndpoint | N | Full URL to an OAuth2 identity provider access token endpoint. Required when `authType` is set to `oidc` or `oidc_private_key_jwt` | "https://identity.example.com/v1/token" | -| oidcClientID | N | The OAuth2 client ID that has been provisioned in the identity provider. Required when `authType` is set to `oidc` or `oidc_private_key_jwt` | `dapr-kafka` | +| disableTls | N | Disable TLS for transport security. To disable, you're required to set value to `"true"`. This is not recommended for use in production. Defaults to `"false"`. | `"true"`, `"false"` | +| oidcTokenEndpoint | N | Full URL to an OAuth2 identity provider access token endpoint. Required when `authType` is set to `oidc` | "https://identity.example.com/v1/token" | +| oidcClientID | N | The OAuth2 client ID that has been provisioned in the identity provider. Required when `authType` is set to `oidc` | `dapr-kafka` | | oidcClientSecret | N | The OAuth2 client secret that has been provisioned in the identity provider: Required when `authType` is set to `oidc` | `"KeFg23!"` | | oidcScopes | N | Comma-delimited list of OAuth2/OIDC scopes to request with the access token. Recommended when `authType` is set to `oidc` or `oidc_private_key_jwt`. Defaults to `"openid"` | `"openid,kafka-prod"` | | oidcClientAssertionCert | N | The OAuth2 client assertion certificate used for authentication. Required when `authType` is set to `oidc_private_key_jwt`. Can be `secretKeyRef` to use a secret reference | `"-----BEGIN CERTIFICATE-----\n...\n-----END CERTIFICATE-----"` | diff --git a/daprdocs/layouts/_shortcodes/dapr-latest-version.html b/daprdocs/layouts/_shortcodes/dapr-latest-version.html index da12c873eb6..f37a9b07109 100644 --- a/daprdocs/layouts/_shortcodes/dapr-latest-version.html +++ b/daprdocs/layouts/_shortcodes/dapr-latest-version.html @@ -1 +1 @@ -{{- if .Get "short" }}1.16{{ else if .Get "long" }}1.16.6{{ else if .Get "cli" }}1.16.5{{ else }}1.16.6{{ end -}} +{{- if .Get "short" }}1.16{{ else if .Get "long" }}1.16.9{{ else if .Get "cli" }}1.16.5{{ else }}1.16.9{{ end -}} diff --git a/daprdocs/static/images/dapr-agents/agents-blue.png b/daprdocs/static/images/dapr-agents/agents-blue.png new file mode 100644 index 00000000000..90432cb6d4c Binary files /dev/null and b/daprdocs/static/images/dapr-agents/agents-blue.png differ diff --git a/daprdocs/static/images/dapr-agents/concepts-agents-overview.png b/daprdocs/static/images/dapr-agents/concepts-agents-overview.png index f496565c640..c227f4d0f04 100644 Binary files a/daprdocs/static/images/dapr-agents/concepts-agents-overview.png and b/daprdocs/static/images/dapr-agents/concepts-agents-overview.png differ diff --git a/daprdocs/static/presentations/dapr-slidedecks.zip b/daprdocs/static/presentations/dapr-slidedecks.zip index 4acaaf29e92..f1ae7c9f76d 100644 Binary files a/daprdocs/static/presentations/dapr-slidedecks.zip and b/daprdocs/static/presentations/dapr-slidedecks.zip differ diff --git a/hugo.yaml b/hugo.yaml index cc85b83ecd8..dee9e42b86e 100644 --- a/hugo.yaml +++ b/hugo.yaml @@ -133,6 +133,11 @@ params: # current doc set. version: v1.17 + # Flag used in the "version-banner" partial to decide whether to display a + # banner on every page indicating that this is an archived version of the docs. + # Set this flag to "true" if you want to display the banner. + archived_version: false + # A link to latest version of the docs. Used in the "version-banner" partial to # point people to the main doc site. url_latest_version: https://docs.dapr.io