Add Akeyless Doc

.github/workflows/website-root.yml

@@ -4,11 +4,11 @@ on:
   workflow_dispatch:
   push:
     branches:
-      - v1.15
+      - v1.16
   pull_request:
     types: [opened, synchronize, reopened, closed]
     branches:
-      - v1.15
+      - v1.16
 
 concurrency:
   # Cancel the previously triggered build for only PR build.
@@ -50,18 +50,18 @@ jobs:
           if [ $GITHUB_EVENT_NAME == 'pull_request' ]; then
             STAGING_URL="https://${SWA_BASE}-${{github.event.number}}.westus2.azurestaticapps.net/"
           fi
-          hugo ${STAGING_URL+-b "$STAGING_URL"}
+          hugo ${STAGING_URL+-b "$STAGING_URL"} --minify
       - name: Deploy docs site
         uses: Azure/static-web-apps-deploy@v1
         with:
           azure_static_web_apps_api_token: ${{ secrets.AZURE_STATIC_WEB_APPS_API_TOKEN_PROUD_BAY_0E9E0E81E }}
           repo_token: ${{ secrets.GITHUB_TOKEN }}
           action: "upload"
-          app_location: "/daprdocs/public/"
+          app_location: "/daprdocs/public"
           output_location: "/"
           skip_app_build: true
           skip_deploy_on_missing_secrets: true
-      - name: Upload Hugo artifacts
+      - name: Upload Hugo artifacts for Algolia
         uses: actions/upload-artifact@v4
         with:
           name: hugo_build
@@ -95,8 +95,8 @@ jobs:
         uses: actions/checkout@v4
         with:
           submodules: false
-      - name: Download Hugo artifacts
-        uses: actions/download-artifact@v3
+      - name: Download Hugo artifacts for Algolia
+        uses: actions/download-artifact@v4
         with:
           name: hugo_build
           path: site/

README.md

@@ -16,8 +16,8 @@ The following branches are currently maintained:
 
 | Branch                                                       | Website                    | Description                                                                                      |
 | ------------------------------------------------------------ | -------------------------- | ------------------------------------------------------------------------------------------------ |
-| [v1.15](https://github.com/dapr/docs) (primary)               | https://docs.dapr.io       | Latest Dapr release documentation. Typo fixes, clarifications, and most documentation goes here. |
-| [v1.16](https://github.com/dapr/docs/tree/v1.16) (pre-release) | https://v1-16.docs.dapr.io/ | Pre-release documentation. Doc updates that are only applicable to v1.15+ go here.                |
+| [v1.16](https://github.com/dapr/docs) (primary)               | https://docs.dapr.io       | Latest Dapr release documentation. Typo fixes, clarifications, and most documentation goes here. |
+| [v1.17](https://github.com/dapr/docs/tree/v1.16) (pre-release) | https://v1-17.docs.dapr.io/ | Pre-release documentation. Doc updates that are only applicable to v1.16+ go here.                |
 
 For more information visit the [Dapr branch structure](https://docs.dapr.io/contributing/docs-contrib/contributing-docs/#branch-guidance) document.
 
@@ -68,13 +68,9 @@ Continue with the [Run local server](#run-local-server) steps.
 1. Ensure pre-requisites are installed.
 1. [Fork](https://github.com/dapr/docs/fork) and clone this repository.
 
-1. Change to daprdocs directory:
+1. Make sure you are in the root folder for the docs repo. You should find a hugo.yaml file in this directory.
 
-```sh
-cd ./daprdocs
-```
-
-4. Update submodules:
+1. Update submodules:
 
 ```sh
 git submodule update --init --recursive

daprdocs/content/en/concepts/overview.md

@@ -141,6 +141,14 @@ Dapr can be used from any developer framework. Here are some that have been inte
 | [JavaScript](https://github.com/dapr/js-sdk) | [Express](https://expressjs.com/) | Build Express applications with Dapr APIs
 | [PHP]({{% ref php %}}) | | You can serve with Apache, Nginx, or Caddyserver.
 
+#### Dapr Agents
+
+![Dapr Agents  Overview](/images/dapr-agents/concepts-agents-overview.png)
+
+
+[Dapr Agents]({{% ref "../developing-applications/dapr-agents" %}}) is a Python framework for building intelligent, durable agents powered by LLMs. It provides agent-centric capabilities such as tool calling, memory management, [MCP support](https://modelcontextprotocol.io/) and agent orchestration, while leveraging Dapr for durability, observability, and security, at scale.
+
+
 #### Integrations and extensions
 
 Visit the [integrations]({{% ref integrations %}}) page to learn about some of the first-class support Dapr has for various frameworks and external products, including:

daprdocs/content/en/concepts/security-concept.md

@@ -244,7 +244,7 @@ The audit was a holistic security audit with the following goals:
 
 - Formalize a threat model of Dapr
 - Perform manual code review
-- Evaluate Daprs fuzzing suite against the formalized threat model
+- Evaluate Dapr's fuzzing suite against the formalized threat model
 - Carry out a SLSA review of Dapr.
 
 You can find the full report [here](/docs/Dapr-september-2023-security-audit-report.pdf).

daprdocs/content/en/concepts/terminology.md

@@ -10,15 +10,17 @@ This page details all of the common terms you may come across in the Dapr docs.
 
 | Term | Definition | More information |
 |:-----|------------|------------------|
-| App/Application | A running service/binary, usually one that you as the user create and run.
+| App/Application | A running service/binary, usually one that you as the user create and run.                                                                                                                                                                                                                      
 | Building block | An API that Dapr provides to users to help in the creation of microservices and applications. | [Dapr building blocks]({{% ref building-blocks-concept %}})
 | Component | Modular types of functionality that are used either individually or with a collection of other components, by a Dapr building block. | [Dapr components]({{% ref components-concept %}})
 | Configuration | A YAML file declaring all of the settings for Dapr sidecars or the Dapr control plane. This is where you can configure control plane mTLS settings, or the tracing and middleware settings for an application instance. | [Dapr configuration]({{% ref configuration-concept %}})
 | Dapr | Distributed Application Runtime. | [Dapr overview]({{% ref overview %}})
+| Dapr Actors | A Dapr building block that implements the virtual actor pattern for building stateful, single-threaded objects with identity, lifecycle, and concurrency management. | [Actors overview]({{% ref actors-overview %}})
+| Dapr Agents | A developer framework built on top of Dapr Python SDK for creating durable agentic applications powered by LLMs. | [Dapr Agents]({{% ref "../developing-applications/dapr-agents" %}})
 | Dapr control plane | A collection of services that are part of a Dapr installation on a hosting platform such as a Kubernetes cluster. This allows Dapr-enabled applications to run on the platform and handles Dapr capabilities such as actor placement, Dapr sidecar injection, or certificate issuance/rollover. | [Self-hosted overview]({{% ref self-hosted-overview %}})<br />[Kubernetes overview]({{% ref kubernetes-overview %}})
+| Dapr Workflows | A Dapr building block for authoring code-first workflows with durable execution that survive crashes, support long-running processes, and enable human-in-the-loop interactions. | [Workflow overview]({{% ref workflow-overview %}})
 | HTTPEndpoint | HTTPEndpoint is a Dapr resource use to identify non-Dapr endpoints to invoke via the service invocation API. | [Service invocation API]({{% ref service_invocation_api %}})
 | Namespacing | Namespacing in Dapr provides isolation, and thus provides multi-tenancy. | Learn more about namespacing [components]({{% ref component-scopes %}}), [service invocation]({{% ref service-invocation-namespaces %}}), [pub/sub]({{% ref pubsub-namespaces %}}), and [actors]({{% ref namespaced-actors %}})
 | Self-hosted | Windows/macOS/Linux machine(s) where you can run your applications with Dapr. Dapr provides the capability to run on machines in "self-hosted" mode. | [Self-hosted mode]({{% ref self-hosted-overview %}})
-| Service | A running application or binary. This can refer to your application or to a Dapr application.
-| Sidecar | A program that runs alongside your application as a separate process or container. | [Sidecar pattern](https://docs.microsoft.com/azure/architecture/patterns/sidecar)
-
+| Service | A running application or binary. This can refer to your application or to a Dapr application.                       
+| Sidecar | A program that runs alongside your application as a separate process or container. | [Sidecar pattern](https://docs.microsoft.com/azure/architecture/patterns/sidecar) 

daprdocs/content/en/contributing/docs-contrib/maintainer-guide.md

@@ -103,24 +103,22 @@ These steps will prepare the latest release branch for archival.
    git checkout -b release_v1.0
    ```
 
-1. In VS Code, navigate to `/daprdocs/config.toml`.
-1. Add the following TOML to the `# Versioning` section (around line 154):
-
-   ```toml
-   version_menu = "v1.0"
-   version = "v1.0"
-   archived_version = true
-   url_latest_version = "https://docs.dapr.io"
-
-   [[params.versions]]
-     version = "v1.2 (preview)"
-     url = "v1-2.docs.dapr.io"
-   [[params.versions]]
-     version = "v1.1 (latest)"
-     url = "#"
-   [[params.versions]]
-     version = "v1.0"
-     url = "https://v1-0.docs.dapr.io"
+1. In VS Code, navigate to `hugo.yaml` located in the root.
+1. Add the following configuration to the `# Versioning` section (around line 121 and onwards):
+
+   ```yaml
+   version_menu: "v1.0"
+   version: "v1.0"
+   archived_version: true
+   url_latest_version: "https://docs.dapr.io"
+
+   versions:
+    - version: v1.2 (preview)
+      url: https://v1-2.docs.dapr.io
+    - version: v1.1 (latest)
+      url: "#"
+    - version: v1.0
+      url: https://v1-0.docs.dapr.io
    ```
 
 1. Delete `.github/workflows/website-root.yml`.
@@ -146,26 +144,25 @@ These steps will prepare the upcoming release branch for promotion to latest rel
    git checkout -b release_v1.1
    ```
 
-1. In VS Code, navigate to `/daprdocs/config.toml`.
-1. Update line 1 to `baseURL - https://docs.dapr.io/`.
-1. Update the `# Versioning` section (around line 154) to display the correct versions and tags:
+1. In VS Code, navigate to `hugo.yaml` located in the root.
+1. Update line 1 to `baseURL: https://docs.dapr.io/`.
+1. Update the `# Versioning` section (around line 121 and onwards) to display the correct versions and tags:
 
-   ```toml
+   ```yaml
    # Versioning
-   version_menu = "v1.1 (latest)"
-   version = "v1.1"
-   archived_version = false
-   url_latest_version = "https://docs.dapr.io"
-
-   [[params.versions]]
-     version = "v1.2 (preview)"
-     url = "v1-2.docs.dapr.io"
-   [[params.versions]]
-     version = "v1.1 (latest)"
-     url = "#"
-   [[params.versions]]
-     version = "v1.0"
-     url = "https://v1-0.docs.dapr.io"
+   version_menu: "v1.1 (latest)"
+   version: "v1.1"
+   archived_version: false
+   url_latest_version: https://docs.dapr.io
+   github_branch: v1.1
+
+   versions:
+    - version: v1.2 (preview)
+      url: https://v1-2.docs.dapr.io
+    - version: v1.1 (latest)
+      url: "#"
+    - version: v1.0
+      url: https://v1-0.docs.dapr.io
    ```
 
 1. Navigate to `.github/workflows/website-root.yml`. 
@@ -194,6 +191,7 @@ These steps will prepare the upcoming release branch for promotion to latest rel
 | [v1.2](https://github.com/dapr/docs/tree/v1.2) (pre-release) | https://v1-2.docs.dapr.io/ | Pre-release documentation. Doc updates that are only applicable to v1.2+ go here.                |
 ```
 
+1. Update the _Supported versions_ table in `support-release-policy.md`; add a new line at the top of the table with the new version of the runtime and SDKs. Change the releases which are older than n-2 to be `Unsupported`.
 1. Update the `dapr-latest-version.html` shortcode partial to the new minor/patch version (in this example, `1.1.0` and `1.1`).
 1. Commit the staged changes and push to your branch (`release_v1.1`).
 1. Open a PR from `release/v1.1` to `v1.1`.

daprdocs/content/en/developing-applications/building-blocks/actors/namespaced-actors.md

@@ -25,7 +25,7 @@ In self-hosted mode, you can specify the namespace for a Dapr instance by settin
 {{% /tab %}}
 
 {{% tab "Kubernetes" %}}
-On Kubernetes, you can create and configure namepaces when deploying actor applications. For example, start with the following `kubectl` commands:
+On Kubernetes, you can create and configure namespaces when deploying actor applications. For example, start with the following `kubectl` commands:
 
 ```bash
 kubectl create namespace namespace-actorA

daprdocs/content/en/developing-applications/building-blocks/conversation/conversation-overview.md

@@ -14,19 +14,24 @@ Dapr's conversation API reduces the complexity of securely and reliably interact
 
 <img src="/images/conversation-overview.png" width=800 alt="Diagram showing the flow of a user's app communicating with Dapr's LLM components.">
 
-In additon to enabling critical performance and security functionality (like [prompt caching]({{% ref "#prompt-caching" %}}) and [PII scrubbing]({{% ref "#personally-identifiable-information-pii-obfuscation" %}})), you can also pair the conversation API with Dapr functionalities, like:
-- Resiliency circuit breakers and retries to circumvent limit and token errors, or 
-- Middleware to authenticate requests coming to and from the LLM
+In addition to enabling critical performance and security functionality (like [prompt caching]({{% ref "#prompt-caching" %}}) and [PII scrubbing]({{% ref "#personally-identifiable-information-pii-obfuscation" %}})), the conversation API also provides:
 
-Dapr provides observability by issuing metrics for your LLM interactions.
+- **Tool calling capabilities** that allow LLMs to interact with external functions and APIs, enabling more sophisticated AI applications
+- **OpenAI-compatible interface** for seamless integration with existing AI workflows and tools
+
+You can also pair the conversation API with Dapr functionalities, like:
+
+- Resiliency policies including circuit breakers to handle repeated errors, timeouts to safeguards from slow responses, and retries for temporary network failures
+- Observability with metrics and distributed tracing using OpenTelemetry and Zipkin
+- Middleware to authenticate requests to and from the LLM
 
 ## Features
 
 The following features are out-of-the-box for [all the supported conversation components]({{% ref supported-conversation %}}).
 
 ### Prompt caching
 
-Prompt caching optimizes performance by storing and reusing prompts that are often repeated across multiple API calls. To significantly reduce latency and cost, Dapr stores frequent prompts in a local cache to be reused by your cluster, pod, or other, instead of reprocessing the information for every new request. 
+The Conversation API includes a built-in caching mechanism (enabled by the cacheTTL parameter) that optimizes both performance and cost by storing previous model responses for faster delivery to repetitive requests. This is particularly valuable in scenarios where similar prompt patterns occur frequently. When caching is enabled, Dapr creates a deterministic hash of the prompt text and all configuration parameters, checks if a valid cached response exists for this hash within the time period (for example, 10 minutes), and returns the cached response immediately if found. If no match exists, Dapr makes the API call and stores the result. This eliminates external API calls, lowers latency, and avoids provider charges for repeated requests. The cache exists entirely within your runtime environment, with each Dapr sidecar maintaining its own local cache.
 
 ### Personally identifiable information (PII) obfuscation
 
@@ -45,13 +50,24 @@ The PII scrubber obfuscates the following user information:
 - SHA-256 hex
 - MD5 hex
 
+### Tool calling support
+
+The conversation API supports advanced tool calling capabilities that allow LLMs to interact with external functions and APIs. This enables you to build sophisticated AI applications that can:
+
+- Execute custom functions based on user requests
+- Integrate with external services and databases
+- Provide dynamic, context-aware responses
+- Create multi-step workflows and automation
+
+Tool calling follows [OpenAI's function calling format](https://platform.openai.com/docs/guides/function-calling), making it easy to integrate with existing AI development workflows and tools.
+
 ## Demo
 
 Watch the demo presented during [Diagrid's Dapr v1.15 celebration](https://www.diagrid.io/videos/dapr-1-15-deep-dive) to see how the conversation API works using the .NET SDK.
 
 {{< youtube id=NTnwoDhHIcQ start=5444 >}}
 
-## Try out conversation
+## Try out conversation API
 
 ### Quickstarts and tutorials