From 03dd1788399e8c867e81c83451060b18fb00281f Mon Sep 17 00:00:00 2001 From: yaron2 Date: Tue, 9 Dec 2025 16:39:36 -0800 Subject: [PATCH 01/22] Add OpenAI integration docs Signed-off-by: yaron2 --- .../openai-agents/_index.md | 12 ++ .../openai-agents/openai-agents-sessions.md | 119 ++++++++++++++++++ 2 files changed, 131 insertions(+) create mode 100644 daprdocs/content/en/developing-applications/openai-agents/_index.md create mode 100644 daprdocs/content/en/developing-applications/openai-agents/openai-agents-sessions.md diff --git a/daprdocs/content/en/developing-applications/openai-agents/_index.md b/daprdocs/content/en/developing-applications/openai-agents/_index.md new file mode 100644 index 00000000000..c93f27f6c3e --- /dev/null +++ b/daprdocs/content/en/developing-applications/openai-agents/_index.md @@ -0,0 +1,12 @@ +--- +type: docs +title: "OpenAI Agents" +linkTitle: "OpenAI Agents" +weight: 25 +description: "Dapr first-class integrations with OpenAI Agents" +--- + +### What is the Dapr OpenAI integration? + +Dapr provides powerful APIs for developers looking to build OpenAI agents that scale and operate reliably in producton. Dapr provides first class integratons that range from agent session management to connecting agents via pub/sub and orchestrating agentic workflows. The Dapr OpenAI integration is a Python package that developers can use to augment OpenAI agents with the various Dapr APIs. + \ No newline at end of file diff --git a/daprdocs/content/en/developing-applications/openai-agents/openai-agents-sessions.md b/daprdocs/content/en/developing-applications/openai-agents/openai-agents-sessions.md new file mode 100644 index 00000000000..2463fe6fb92 --- /dev/null +++ b/daprdocs/content/en/developing-applications/openai-agents/openai-agents-sessions.md @@ -0,0 +1,119 @@ +--- +type: docs +title: "Agent Sessions" +linkTitle: "Agent Sessions" +weight: 20 +description: "How to use Dapr to reliably and securely manage agent state" +--- + +## Overview + +By using Dapr to manage the state and [session data for OpenAI agents](https://openai.github.io/openai-agents-python/sessions/), users can store agent state in all databases supported by Dapr, including key/value stores, caches and SQL databases. Developers also get built-in tracing, metrics and resiliency policies that make agent session data operate reliably in production. + +## 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-selfhost.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 %}} + +### Install Dependencies + +```bash +pip install openai-agents dapr +``` + +### Create an OpenAI Agent + +Let's create a simple OpenAI agent. Put the following in a file named `openai_agent.py`: + +```python +import asyncio +from agents import Agent, Runner +from agents.extensions.memory.dapr_session import DaprSession + +async def main(): + agent = Agent( + name="Assistant", + instructions="Reply very concisely.", + ) + + session = DaprSession.from_address( + session_id="123", + state_store_name="statestore" + ) + + result = await Runner.run(agent, "What city is the Golden Gate Bridge in?", session=session) + print(result.final_output) + + result = await Runner.run(agent, "What state is it in?", session=session) + print(result.final_output) + + result = await Runner.run(agent, "What's the population?", session=session) + print(result.final_output) + +asyncio.run(main()) +``` + +### 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: + +`statestore.yaml`: + +```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: "" +``` + +### Run The Agent + +Now you will run the local Dapr process and your Python script using the Dapr CLI, a local development tool that makes it easy to launch both Dapr and your app side-by-side. + +```bash +dapr run --app-id openaisessions --dapr-grpc-port 50001 --resources-path ./components -- python3 ./openai_agent.py +``` + +Open `http://localhost:9411` to view your the traces and dependency graph! + +## Next Steps + +Now that you have an OpenAI agent using Dapr to manage the agent sessions, explore more about what you can do with the [State API]({{% ref "state-management-overview" %}}) and how to enable [resiliency policies]({{% ref resiliency-overview %}}) for enhanced reliability. From 9b11547aef03398ca996da4893d0dbd47bf5eb2f Mon Sep 17 00:00:00 2001 From: yaron2 Date: Tue, 9 Dec 2025 16:41:30 -0800 Subject: [PATCH 02/22] add openai link Signed-off-by: yaron2 --- .../openai-agents/openai-agents-sessions.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/daprdocs/content/en/developing-applications/openai-agents/openai-agents-sessions.md b/daprdocs/content/en/developing-applications/openai-agents/openai-agents-sessions.md index 2463fe6fb92..8d4ce754955 100644 --- a/daprdocs/content/en/developing-applications/openai-agents/openai-agents-sessions.md +++ b/daprdocs/content/en/developing-applications/openai-agents/openai-agents-sessions.md @@ -116,4 +116,4 @@ Open `http://localhost:9411` to view your the traces and dependency graph! ## Next Steps -Now that you have an OpenAI agent using Dapr to manage the agent sessions, explore more about what you can do with the [State API]({{% ref "state-management-overview" %}}) and how to enable [resiliency policies]({{% ref resiliency-overview %}}) for enhanced reliability. +Now that you have an OpenAI agent using Dapr to manage the agent sessions, explore more about what you can do with the [State API]({{% ref "state-management-overview" %}}) and how to enable [resiliency policies]({{% ref resiliency-overview %}}) for enhanced reliability. Read more about OpenAI agent sessions and Dapr [here](https://openai.github.io/openai-agents-python/sessions/). From 13527c09626784156f1ab59e2468d0c6e6e20503 Mon Sep 17 00:00:00 2001 From: Yaron Schneider Date: Thu, 11 Dec 2025 19:32:52 -0800 Subject: [PATCH 03/22] Update daprdocs/content/en/developing-applications/openai-agents/_index.md Co-authored-by: Mark Fussell Signed-off-by: Yaron Schneider --- .../content/en/developing-applications/openai-agents/_index.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/daprdocs/content/en/developing-applications/openai-agents/_index.md b/daprdocs/content/en/developing-applications/openai-agents/_index.md index c93f27f6c3e..978e7c5d54c 100644 --- a/daprdocs/content/en/developing-applications/openai-agents/_index.md +++ b/daprdocs/content/en/developing-applications/openai-agents/_index.md @@ -8,5 +8,5 @@ description: "Dapr first-class integrations with OpenAI Agents" ### What is the Dapr OpenAI integration? -Dapr provides powerful APIs for developers looking to build OpenAI agents that scale and operate reliably in producton. Dapr provides first class integratons that range from agent session management to connecting agents via pub/sub and orchestrating agentic workflows. The Dapr OpenAI integration is a Python package that developers can use to augment OpenAI agents with the various Dapr APIs. +Dapr provides APIs for developers looking to build OpenAI agents that scale and operate reliably in production. Dapr provides first class integrations that range from agent session management to connecting agents via pub/sub and orchestrating agentic workflows. The Dapr OpenAI integration is a Python package that developers can use to augment OpenAI agents with the various Dapr APIs. \ No newline at end of file From a03f8301ebac25edade5b28e26f3a7ede3fded2d Mon Sep 17 00:00:00 2001 From: Yaron Schneider Date: Thu, 11 Dec 2025 19:33:44 -0800 Subject: [PATCH 04/22] Update daprdocs/content/en/developing-applications/openai-agents/openai-agents-sessions.md Co-authored-by: Mark Fussell Signed-off-by: Yaron Schneider --- .../openai-agents/openai-agents-sessions.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/daprdocs/content/en/developing-applications/openai-agents/openai-agents-sessions.md b/daprdocs/content/en/developing-applications/openai-agents/openai-agents-sessions.md index 8d4ce754955..c328303c724 100644 --- a/daprdocs/content/en/developing-applications/openai-agents/openai-agents-sessions.md +++ b/daprdocs/content/en/developing-applications/openai-agents/openai-agents-sessions.md @@ -106,7 +106,7 @@ spec: ### Run The Agent -Now you will run the local Dapr process and your Python script using the Dapr CLI, a local development tool that makes it easy to launch both Dapr and your app side-by-side. +Now run the local Dapr process and your Python script using the Dapr CLI. ```bash dapr run --app-id openaisessions --dapr-grpc-port 50001 --resources-path ./components -- python3 ./openai_agent.py From 91275316f268c3034a03a66c28e3719d96287cca Mon Sep 17 00:00:00 2001 From: Yaron Schneider Date: Thu, 11 Dec 2025 19:34:00 -0800 Subject: [PATCH 05/22] Update daprdocs/content/en/developing-applications/openai-agents/openai-agents-sessions.md Co-authored-by: Mark Fussell Signed-off-by: Yaron Schneider --- .../openai-agents/openai-agents-sessions.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/daprdocs/content/en/developing-applications/openai-agents/openai-agents-sessions.md b/daprdocs/content/en/developing-applications/openai-agents/openai-agents-sessions.md index c328303c724..5e06a376f08 100644 --- a/daprdocs/content/en/developing-applications/openai-agents/openai-agents-sessions.md +++ b/daprdocs/content/en/developing-applications/openai-agents/openai-agents-sessions.md @@ -112,7 +112,7 @@ Now run the local Dapr process and your Python script using the Dapr CLI. dapr run --app-id openaisessions --dapr-grpc-port 50001 --resources-path ./components -- python3 ./openai_agent.py ``` -Open `http://localhost:9411` to view your the traces and dependency graph! +Open `http://localhost:9411` to view your the traces and dependency graph. ## Next Steps From 6cb1abd668c77633b0dfb57d9bfaca51242152b4 Mon Sep 17 00:00:00 2001 From: Yaron Schneider Date: Thu, 11 Dec 2025 19:34:29 -0800 Subject: [PATCH 06/22] Update daprdocs/content/en/developing-applications/openai-agents/openai-agents-sessions.md Co-authored-by: Mark Fussell Signed-off-by: Yaron Schneider --- .../openai-agents/openai-agents-sessions.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/daprdocs/content/en/developing-applications/openai-agents/openai-agents-sessions.md b/daprdocs/content/en/developing-applications/openai-agents/openai-agents-sessions.md index 5e06a376f08..8619c77fcc0 100644 --- a/daprdocs/content/en/developing-applications/openai-agents/openai-agents-sessions.md +++ b/daprdocs/content/en/developing-applications/openai-agents/openai-agents-sessions.md @@ -116,4 +116,6 @@ Open `http://localhost:9411` to view your the traces and dependency graph. ## Next Steps -Now that you have an OpenAI agent using Dapr to manage the agent sessions, explore more about what you can do with the [State API]({{% ref "state-management-overview" %}}) and how to enable [resiliency policies]({{% ref resiliency-overview %}}) for enhanced reliability. Read more about OpenAI agent sessions and Dapr [here](https://openai.github.io/openai-agents-python/sessions/). +Now that you have an OpenAI 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. + +Read more about OpenAI agent sessions and Dapr [here](https://openai.github.io/openai-agents-python/sessions/). From 22f96c18424cf37497a1c7e59042f629a7ce39e7 Mon Sep 17 00:00:00 2001 From: Yaron Schneider Date: Thu, 11 Dec 2025 19:35:03 -0800 Subject: [PATCH 07/22] Update daprdocs/content/en/developing-applications/openai-agents/openai-agents-sessions.md Co-authored-by: Mark Fussell Signed-off-by: Yaron Schneider --- .../openai-agents/openai-agents-sessions.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/daprdocs/content/en/developing-applications/openai-agents/openai-agents-sessions.md b/daprdocs/content/en/developing-applications/openai-agents/openai-agents-sessions.md index 8619c77fcc0..ab2fa90f448 100644 --- a/daprdocs/content/en/developing-applications/openai-agents/openai-agents-sessions.md +++ b/daprdocs/content/en/developing-applications/openai-agents/openai-agents-sessions.md @@ -12,7 +12,7 @@ By using Dapr to manage the state and [session data for OpenAI agents](https://o ## 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-selfhost.md %}}). +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: From 28acb8124bf74bad51b1585bcf7b2b09f591dc28 Mon Sep 17 00:00:00 2001 From: Yaron Schneider Date: Mon, 15 Dec 2025 09:39:49 -0800 Subject: [PATCH 08/22] Update daprdocs/content/en/developing-applications/openai-agents/openai-agents-sessions.md Co-authored-by: Mark Fussell Signed-off-by: Yaron Schneider --- .../openai-agents/openai-agents-sessions.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/daprdocs/content/en/developing-applications/openai-agents/openai-agents-sessions.md b/daprdocs/content/en/developing-applications/openai-agents/openai-agents-sessions.md index ab2fa90f448..291cf76ac1d 100644 --- a/daprdocs/content/en/developing-applications/openai-agents/openai-agents-sessions.md +++ b/daprdocs/content/en/developing-applications/openai-agents/openai-agents-sessions.md @@ -111,7 +111,10 @@ Now run the local Dapr process and your Python script using the Dapr CLI. ```bash dapr run --app-id openaisessions --dapr-grpc-port 50001 --resources-path ./components -- python3 ./openai_agent.py ``` +You can see [the session data stored in Redis]({{% ref "getting-started/get-started-api" %}}#step-4-see-how-the-state-is-stored-in-redis) with the following command +```bash +hgetall "123:messages" Open `http://localhost:9411` to view your the traces and dependency graph. ## Next Steps From e86ee2ea8e821d582ed33422d4e1c6cdf74f71d4 Mon Sep 17 00:00:00 2001 From: yaron2 Date: Mon, 15 Dec 2025 09:43:33 -0800 Subject: [PATCH 09/22] address feedback, move to new AI structure Signed-off-by: yaron2 --- daprdocs/content/en/developing-ai/_index.md | 7 + .../agent-integrations/_index.md | 19 +++ .../openai-agents/_index.md | 12 ++ .../openai-agents/openai-agents-sessions.md | 127 ++++++++++++++++++ .../dapr-agents/_index.md | 0 .../dapr-agents/dapr-agents-core-concepts.md | 0 .../dapr-agents-getting-started.md | 0 .../dapr-agents/dapr-agents-integrations.md | 0 .../dapr-agents/dapr-agents-introduction.md | 0 .../dapr-agents/dapr-agents-patterns.md | 0 .../dapr-agents/dapr-agents-quickstarts.md | 28 ++++ .../dapr-agents/dapr-agents-why.md | 0 12 files changed, 193 insertions(+) create mode 100644 daprdocs/content/en/developing-ai/_index.md create mode 100644 daprdocs/content/en/developing-ai/agent-integrations/_index.md create mode 100644 daprdocs/content/en/developing-ai/agent-integrations/openai-agents/_index.md create mode 100644 daprdocs/content/en/developing-ai/agent-integrations/openai-agents/openai-agents-sessions.md rename daprdocs/content/en/{developing-applications => developing-ai}/dapr-agents/_index.md (100%) rename daprdocs/content/en/{developing-applications => developing-ai}/dapr-agents/dapr-agents-core-concepts.md (100%) rename daprdocs/content/en/{developing-applications => developing-ai}/dapr-agents/dapr-agents-getting-started.md (100%) rename daprdocs/content/en/{developing-applications => developing-ai}/dapr-agents/dapr-agents-integrations.md (100%) rename daprdocs/content/en/{developing-applications => developing-ai}/dapr-agents/dapr-agents-introduction.md (100%) rename daprdocs/content/en/{developing-applications => developing-ai}/dapr-agents/dapr-agents-patterns.md (100%) create mode 100644 daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-quickstarts.md rename daprdocs/content/en/{developing-applications => developing-ai}/dapr-agents/dapr-agents-why.md (100%) diff --git a/daprdocs/content/en/developing-ai/_index.md b/daprdocs/content/en/developing-ai/_index.md new file mode 100644 index 00000000000..7ebd131d7fe --- /dev/null +++ b/daprdocs/content/en/developing-ai/_index.md @@ -0,0 +1,7 @@ +--- +type: docs +title: "Developing AI with Dapr" +linkTitle: "Developing AI" +description: "Information on who to build reliable and secure AI systems with Dapr" +weight: 31 +--- diff --git a/daprdocs/content/en/developing-ai/agent-integrations/_index.md b/daprdocs/content/en/developing-ai/agent-integrations/_index.md new file mode 100644 index 00000000000..9adc139280d --- /dev/null +++ b/daprdocs/content/en/developing-ai/agent-integrations/_index.md @@ -0,0 +1,19 @@ +--- +type: docs +title: "Agent Integrations" +linkTitle: "Agent Integrations" +weight: 25 +description: "Information on how to integrate Dapr with other agentic frameworks and runtime" +--- + +### What are Agent Integrations in Dapr? + +Dapr augments and enhances other agentic frameworks by providing them with key critical features for running in production: + +* Durable execution using [Dapr Workflows]({{% ref workflow-overview %}}) for resilient and long-running AI tasks +* Portable agent context & memory using Dapr's [State Management API]({{% ref "state-management-overview" %}}) +* Reliable and secure agent-to-agent communication using [Dapr Pub/Sub]({{% ref "pubsub-overview" %}}) and [Service Invocation +]({{% ref service-invocation-overview %}}) + +With Dapr, developers writing AI systems using the framework of their choice enjoy accelerated development via the Dapr APIs and gain confidence taking agentic systems into production. + \ No newline at end of file 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 new file mode 100644 index 00000000000..0c2021a7007 --- /dev/null +++ b/daprdocs/content/en/developing-ai/agent-integrations/openai-agents/_index.md @@ -0,0 +1,12 @@ +--- +type: docs +title: "OpenAI Agents" +linkTitle: "OpenAI Agents" +weight: 25 +description: "Dapr first-class integrations with OpenAI Agents" +--- + +### What is the Dapr OpenAI Agents integration? + +Dapr provides OpenAI agents first class integrations that range from agent session management to connecting agents via pub/sub and orchestrating agentic workflows. The Dapr OpenAI integration is an extension in the OpenAI Python SDK that developers can use to augment OpenAI agents with the various Dapr APIs. + \ No newline at end of file diff --git a/daprdocs/content/en/developing-ai/agent-integrations/openai-agents/openai-agents-sessions.md b/daprdocs/content/en/developing-ai/agent-integrations/openai-agents/openai-agents-sessions.md new file mode 100644 index 00000000000..d0b2c0d9764 --- /dev/null +++ b/daprdocs/content/en/developing-ai/agent-integrations/openai-agents/openai-agents-sessions.md @@ -0,0 +1,127 @@ +--- +type: docs +title: "Agent Sessions" +linkTitle: "Agent Sessions" +weight: 20 +description: "How to use Dapr to reliably and securely manage agent state" +--- + +## Overview + +By using Dapr to manage the state and [session data for OpenAI agents](https://openai.github.io/openai-agents-python/sessions/), users can store agent state in all databases supported by Dapr, including key/value stores, caches and SQL databases. Developers also get built-in tracing, metrics and resiliency policies that make agent session data operate reliably in production. + +## 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 %}} + +### Install Dependencies + +```bash +pip install openai-agents dapr +``` + +### Create an OpenAI Agent + +Let's create a simple OpenAI agent. Put the following in a file named `openai_agent.py`: + +```python +import asyncio +from agents import Agent, Runner +from agents.extensions.memory.dapr_session import DaprSession + +async def main(): + agent = Agent( + name="Assistant", + instructions="Reply very concisely.", + ) + + session = DaprSession.from_address( + session_id="123", + state_store_name="statestore" + ) + + result = await Runner.run(agent, "What city is the Golden Gate Bridge in?", session=session) + print(result.final_output) + + result = await Runner.run(agent, "What state is it in?", session=session) + print(result.final_output) + + result = await Runner.run(agent, "What's the population?", session=session) + print(result.final_output) + +asyncio.run(main()) +``` + +### 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: + +`statestore.yaml`: + +```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: "" +``` + +### Run The Agent + +Now run the local Dapr process and your Python script using the Dapr CLI. + +```bash +dapr run --app-id openaisessions --dapr-grpc-port 50001 --resources-path ./components -- python3 ./openai_agent.py +``` + +Open `http://localhost:9411` to view your the traces and dependency graph. + +You can see [the session data stored in Redis]({{% ref "getting-started/get-started-api" %}}#step-4-see-how-the-state-is-stored-in-redis) with the following command + +```bash +hgetall "123:messages" +``` + +## Next Steps + +Now that you have an OpenAI 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. + +Read more about OpenAI agent sessions and Dapr [here](https://openai.github.io/openai-agents-python/sessions/). diff --git a/daprdocs/content/en/developing-applications/dapr-agents/_index.md b/daprdocs/content/en/developing-ai/dapr-agents/_index.md similarity index 100% rename from daprdocs/content/en/developing-applications/dapr-agents/_index.md rename to daprdocs/content/en/developing-ai/dapr-agents/_index.md diff --git a/daprdocs/content/en/developing-applications/dapr-agents/dapr-agents-core-concepts.md b/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-core-concepts.md similarity index 100% rename from daprdocs/content/en/developing-applications/dapr-agents/dapr-agents-core-concepts.md rename to daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-core-concepts.md diff --git a/daprdocs/content/en/developing-applications/dapr-agents/dapr-agents-getting-started.md b/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-getting-started.md similarity index 100% rename from daprdocs/content/en/developing-applications/dapr-agents/dapr-agents-getting-started.md rename to daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-getting-started.md diff --git a/daprdocs/content/en/developing-applications/dapr-agents/dapr-agents-integrations.md b/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-integrations.md similarity index 100% rename from daprdocs/content/en/developing-applications/dapr-agents/dapr-agents-integrations.md rename to daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-integrations.md diff --git a/daprdocs/content/en/developing-applications/dapr-agents/dapr-agents-introduction.md b/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-introduction.md similarity index 100% rename from daprdocs/content/en/developing-applications/dapr-agents/dapr-agents-introduction.md rename to daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-introduction.md diff --git a/daprdocs/content/en/developing-applications/dapr-agents/dapr-agents-patterns.md b/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-patterns.md similarity index 100% rename from daprdocs/content/en/developing-applications/dapr-agents/dapr-agents-patterns.md rename to daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-patterns.md diff --git a/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-quickstarts.md b/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-quickstarts.md new file mode 100644 index 00000000000..f2a519f9a8b --- /dev/null +++ b/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-quickstarts.md @@ -0,0 +1,28 @@ +--- +type: docs +title: "Quickstarts" +linkTitle: "Quickstarts" +weight: 70 +description: "Get started with Dapr Agents through practical step-by-step examples" +--- + +[Dapr Agents Quickstarts](https://github.com/dapr/dapr-agents/tree/main/quickstarts) demonstrate how to use Dapr Agents to build applications with LLM-powered autonomous agents and event-driven workflows. Each quickstart builds upon the previous one, introducing new concepts incrementally. + +#### Before you begin + +- [Set up your local Dapr environment]({{% ref install-dapr-cli.md %}}). + + +## Quickstarts + +| Scenario | What You'll Learn | +|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------| +| [Hello World](https://github.com/dapr/dapr-agents/tree/main/quickstarts/01-hello-world)
A rapid introduction that demonstrates core Dapr Agents concepts through simple, practical examples. | - **Basic LLM Usage**: Simple text generation with OpenAI models
- **Creating Agents**: Building agents with custom tools in under 20 lines of code

- **Simple Workflows**: Setting up multi-step LLM processes
- **DurableAgent Hosting**: Learn `AgentRunner.run`, `AgentRunner.subscribe`, and `AgentRunner.serve` using the `03_durable_agent_*.py` samples | +| [LLM Call with Dapr Chat Client](https://github.com/dapr/dapr-agents/tree/main/quickstarts/02_llm_call_dapr)
Explore interaction with Language Models through Dapr Agents' `DaprChatClient`, featuring basic text generation with plain text prompts and templates. | - **Text Completion**: Generating responses to prompts
- **Swapping LLM providers**: Switching LLM backends without application code change
- **Resilience**: Setting timeout, retry and circuit-breaking
- **PII Obfuscation**: Automatically detect and mask sensitive user information | +| [LLM Call with OpenAI Client](https://github.com/dapr/dapr-agents/tree/main/quickstarts/02_llm_call_open_ai)
Leverage native LLM client libraries with Dapr Agents using the OpenAI Client for chat completion, audio processing, and embeddings. | - **Text Completion**: Generating responses to prompts
- **Structured Outputs**: Converting LLM responses to Pydantic objects

*Note: Other quickstarts for specific clients are available for [Elevenlabs](https://github.com/dapr/dapr-agents/tree/main/quickstarts/02_llm_call_elevenlabs), [Hugging Face](https://github.com/dapr/dapr-agents/tree/main/quickstarts/02_llm_call_hugging_face), and [Nvidia](https://github.com/dapr/dapr-agents/tree/main/quickstarts/02_llm_call_nvidia).* | +| Standalone & Durable Agents
[Standalone Agent Tool Call](https://github.com/dapr/dapr-agents/tree/main/quickstarts/03-standalone-agent-tool-call) · [Durable Agent Tool Call](https://github.com/dapr/dapr-agents/tree/main/quickstarts/03-durable-agent-tool-call) | - **Standalone Agents**: Build conversational agents with tools in under 20 lines using the `Agent` class
- **Durable Agents**: Upgrade to workflow-backed `DurableAgent` instances with `AgentRunner.run/subscribe/serve`
- **Tool Definition**: Reuse tools with the `@tool` decorator and structured args models
- **Function Calling**: Let LLMs invoke Python functions safely | +| [Agentic Workflow](https://github.com/dapr/dapr-agents/tree/main/quickstarts/04-llm-based-workflows)
Dive into stateful workflows with Dapr Agents by orchestrating sequential and parallel tasks through powerful workflow capabilities. | - **LLM-powered Tasks**: Using language models in workflows
- **Task Chaining**: Creating resilient multi-step processes executing in sequence
- **Fan-out/Fan-in**: Executing activities in parallel; then synchronizing these activities until all preceding activities have completed | +| [Multi-Agent Workflows](https://github.com/dapr/dapr-agents/tree/main/quickstarts/05-multi-agent-workflows)
Explore advanced event-driven workflows featuring a Lord of the Rings themed multi-agent system where autonomous agents collaborate to solve problems. | - **Multi-agent Systems**: Creating a network of specialized agents
- **Event-driven Architecture**: Implementing pub/sub messaging between agents
- **Workflow Orchestration**: Coordinating agents through different selection strategies| +| [Multi-Agent Workflow on Kubernetes](https://github.com/dapr/dapr-agents/tree/main/quickstarts/05-multi-agent-workflow-k8s)
Run multi-agent workflows in Kubernetes, demonstrating deployment and orchestration of event-driven agent systems in a containerized environment. | - **Kubernetes Deployment**: Running agents on Kubernetes
- **Container Orchestration**: Managing agent lifecycles with K8s
- **Service Communication**: Inter-agent communication in K8s | +| [Document Agent with Chainlit](https://github.com/dapr/dapr-agents/tree/main/quickstarts/06-document-agent-chainlit)
Create a conversational agent with an operational UI that can upload, and learn unstructured documents while retaining long-term memory. | - **Conversational Document Agent**: Upload and converse over unstructured documents
- **Cloud Agnostic Storage**: Upload files to multiple storage providers
- **Conversation Memory Storage**: Persists conversation history using external storage. | +| [Data Agent with MCP and Chainlit](https://github.com/dapr/dapr-agents/tree/main/quickstarts/08-data-agent-mcp-chainlit)
Build a conversational agent over a Postgres database using Model Composition Protocol (MCP) with a ChatGPT-like interface. | - **Database Querying**: Natural language queries to relational databases
- **MCP Integration**: Connecting to databases without DB-specific code
- **Data Analysis**: Complex data analysis through conversation | diff --git a/daprdocs/content/en/developing-applications/dapr-agents/dapr-agents-why.md b/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-why.md similarity index 100% rename from daprdocs/content/en/developing-applications/dapr-agents/dapr-agents-why.md rename to daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-why.md From eb8bf40ba5e367bfa2caab06124a923416878256 Mon Sep 17 00:00:00 2001 From: yaron2 Date: Mon, 15 Dec 2025 09:50:06 -0800 Subject: [PATCH 10/22] fix links Signed-off-by: yaron2 --- daprdocs/content/en/_index.md | 2 +- daprdocs/content/en/concepts/overview.md | 2 +- daprdocs/content/en/concepts/terminology.md | 2 +- .../en/developing-ai/dapr-agents/dapr-agents-introduction.md | 2 +- .../content/en/developing-ai/dapr-agents/dapr-agents-why.md | 2 +- daprdocs/content/en/developing-applications/sdks/_index.md | 2 +- 6 files changed, 6 insertions(+), 6 deletions(-) diff --git a/daprdocs/content/en/_index.md b/daprdocs/content/en/_index.md index 7a6c9a21a5c..54ab8f9d4d1 100644 --- a/daprdocs/content/en/_index.md +++ b/daprdocs/content/en/_index.md @@ -28,7 +28,7 @@ Dapr provides APIs for communication, state, workflow, and agentic AI. The APIs Dapr Agents Agentic AI

Create durable agentic AI applications with Dapr Agents.

- + diff --git a/daprdocs/content/en/concepts/overview.md b/daprdocs/content/en/concepts/overview.md index 881c5fd521d..125b040c421 100644 --- a/daprdocs/content/en/concepts/overview.md +++ b/daprdocs/content/en/concepts/overview.md @@ -146,7 +146,7 @@ Dapr can be used from any developer framework. Here are some that have been inte ![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. +[Dapr Agents]({{% ref "../developing-ai/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 diff --git a/daprdocs/content/en/concepts/terminology.md b/daprdocs/content/en/concepts/terminology.md index da9b4f08030..46a4dffe2d6 100644 --- a/daprdocs/content/en/concepts/terminology.md +++ b/daprdocs/content/en/concepts/terminology.md @@ -16,7 +16,7 @@ This page details all of the common terms you may come across in the Dapr docs. | 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 Agents | A developer framework built on top of Dapr Python SDK for creating durable agentic applications powered by LLMs. | [Dapr Agents]({{% ref "../developing-ai/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 %}})
[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 %}}) diff --git a/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-introduction.md b/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-introduction.md index 17cc7dcf7f1..c61cf1f0e2a 100644 --- a/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-introduction.md +++ b/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-introduction.md @@ -68,7 +68,7 @@ Get started with Dapr Agents by following the instructions on the [Getting Start ### Framework Integrations -Dapr Agents integrates with popular Python frameworks and tools. For detailed integration guides and examples, see the [integrations page]({{% ref "developing-applications/dapr-agents/dapr-agents-integrations.md" %}}). +Dapr Agents integrates with popular Python frameworks and tools. For detailed integration guides and examples, see the [integrations page]({{% ref "developing-ai/dapr-agents/dapr-agents-integrations.md" %}}). ## Operational Support diff --git a/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-why.md b/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-why.md index a65ad4d8502..125499a3a16 100644 --- a/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-why.md +++ b/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-why.md @@ -104,7 +104,7 @@ Dapr Agents builds on Dapr's Workflow API, which represents each agent as an act ### Data-Centric AI Agents -With built-in connectivity to over 50 enterprise data sources, Dapr Agents efficiently handles structured and unstructured data. From basic [PDF extraction]({{% ref "/developing-applications/dapr-agents/dapr-agents-integrations.md" %}}) to large-scale database interactions, it enables data-driven AI workflows with minimal code changes. Dapr's [bindings]({{% ref bindings-overview.md %}}) and [state stores]({{% ref supported-state-stores.md %}}), along with MCP support, provide access to numerous data sources for agent data ingestion. +With built-in connectivity to over 50 enterprise data sources, Dapr Agents efficiently handles structured and unstructured data. From basic [PDF extraction]({{% ref "/developing-ai/dapr-agents/dapr-agents-integrations.md" %}}) to large-scale database interactions, it enables data-driven AI workflows with minimal code changes. Dapr's [bindings]({{% ref bindings-overview.md %}}) and [state stores]({{% ref supported-state-stores.md %}}), along with MCP support, provide access to numerous data sources for agent data ingestion. ### Accelerated Development diff --git a/daprdocs/content/en/developing-applications/sdks/_index.md b/daprdocs/content/en/developing-applications/sdks/_index.md index 1982360b30e..ace28b18042 100644 --- a/daprdocs/content/en/developing-applications/sdks/_index.md +++ b/daprdocs/content/en/developing-applications/sdks/_index.md @@ -36,7 +36,7 @@ Select your [preferred language below]({{% ref "#sdk-languages" %}}) to learn mo | Framework | Language | Status | Description | |----------------------------------------|:----------------------|:---------------|:-----------------:| -| [Dapr Agents]({{% ref "../dapr-agents" %}}) | Python | In development | A framework for building LLM-powered autonomous agents that leverages Dapr's distributed systems capabilities for durable execution, with built-in security, observability, and state management. | +| [Dapr Agents]({{% ref "../../developing-ai/dapr-agents" %}}) | Python | In development | A framework for building LLM-powered autonomous agents that leverages Dapr's distributed systems capabilities for durable execution, with built-in security, observability, and state management. | ## Further reading - [Serialization in the Dapr SDKs]({{% ref sdk-serialization.md %}}) From d15370f3b1fe490bd0f0c045ccbee95bd766ab54 Mon Sep 17 00:00:00 2001 From: yaron2 Date: Mon, 15 Dec 2025 09:53:44 -0800 Subject: [PATCH 11/22] remove old content Signed-off-by: yaron2 --- .../dapr-agents/dapr-agents-quickstarts.md | 28 ---- .../openai-agents/_index.md | 12 -- .../openai-agents/openai-agents-sessions.md | 124 ------------------ 3 files changed, 164 deletions(-) delete mode 100644 daprdocs/content/en/developing-applications/dapr-agents/dapr-agents-quickstarts.md delete mode 100644 daprdocs/content/en/developing-applications/openai-agents/_index.md delete mode 100644 daprdocs/content/en/developing-applications/openai-agents/openai-agents-sessions.md diff --git a/daprdocs/content/en/developing-applications/dapr-agents/dapr-agents-quickstarts.md b/daprdocs/content/en/developing-applications/dapr-agents/dapr-agents-quickstarts.md deleted file mode 100644 index cbf9a652261..00000000000 --- a/daprdocs/content/en/developing-applications/dapr-agents/dapr-agents-quickstarts.md +++ /dev/null @@ -1,28 +0,0 @@ ---- -type: docs -title: "Quickstarts" -linkTitle: "Quickstarts" -weight: 70 -description: "Get started with Dapr Agents through practical step-by-step examples" ---- - -[Dapr Agents Quickstarts](https://github.com/dapr/dapr-agents/tree/main/quickstarts) demonstrate how to use Dapr Agents to build applications with LLM-powered autonomous agents and event-driven workflows. Each quickstart builds upon the previous one, introducing new concepts incrementally. - -#### Before you begin - -- [Set up your local Dapr environment]({{% ref install-dapr-cli.md %}}). - - -## Quickstarts - -| Scenario | What You'll Learn | -|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------| -| [Hello World](https://github.com/dapr/dapr-agents/tree/main/quickstarts/01-hello-world)
A rapid introduction that demonstrates core Dapr Agents concepts through simple, practical examples. | - **Basic LLM Usage**: Simple text generation with OpenAI models
- **Creating Agents**: Building agents with custom tools in under 20 lines of code

- **Simple Workflows**: Setting up multi-step LLM processes
- **DurableAgent Hosting**: Learn `AgentRunner.run`, `AgentRunner.subscribe`, and `AgentRunner.serve` using the `03_durable_agent_*.py` samples | -| [LLM Call with Dapr Chat Client](https://github.com/dapr/dapr-agents/tree/main/quickstarts/02-llm-call-dapr)
Explore interaction with Language Models through Dapr Agents' `DaprChatClient`, featuring basic text generation with plain text prompts and templates. | - **Text Completion**: Generating responses to prompts
- **Swapping LLM providers**: Switching LLM backends without application code change
- **Resilience**: Setting timeout, retry and circuit-breaking
- **PII Obfuscation**: Automatically detect and mask sensitive user information | -| [LLM Call with OpenAI Client](https://github.com/dapr/dapr-agents/tree/main/quickstarts/02-llm-call-open-ai)
Leverage native LLM client libraries with Dapr Agents using the OpenAI Client for chat completion, audio processing, and embeddings. | - **Text Completion**: Generating responses to prompts
- **Structured Outputs**: Converting LLM responses to Pydantic objects

*Note: Other quickstarts for specific clients are available for [Elevenlabs](https://github.com/dapr/dapr-agents/tree/main/quickstarts/02-llm-call-elevenlabs), [Hugging Face](https://github.com/dapr/dapr-agents/tree/main/quickstarts/02-llm-call-hugging-face), and [Nvidia](https://github.com/dapr/dapr-agents/tree/main/quickstarts/02-llm-call-nvidia).* | -| Standalone & Durable Agents
[Standalone Agent Tool Call](https://github.com/dapr/dapr-agents/tree/main/quickstarts/03-standalone-agent-tool-call) · [Durable Agent Tool Call](https://github.com/dapr/dapr-agents/tree/main/quickstarts/03-durable-agent-tool-call) | - **Standalone Agents**: Build conversational agents with tools in under 20 lines using the `Agent` class
- **Durable Agents**: Upgrade to workflow-backed `DurableAgent` instances with `AgentRunner.run/subscribe/serve`
- **Tool Definition**: Reuse tools with the `@tool` decorator and structured args models
- **Function Calling**: Let LLMs invoke Python functions safely | -| [Agentic Workflow](https://github.com/dapr/dapr-agents/tree/main/quickstarts/04-llm-based-workflows)
Dive into stateful workflows with Dapr Agents by orchestrating sequential and parallel tasks through powerful workflow capabilities. | - **LLM-powered Tasks**: Using language models in workflows
- **Task Chaining**: Creating resilient multi-step processes executing in sequence
- **Fan-out/Fan-in**: Executing activities in parallel; then synchronizing these activities until all preceding activities have completed | -| [Multi-Agent Workflows](https://github.com/dapr/dapr-agents/tree/main/quickstarts/05-multi-agent-workflows)
Explore advanced event-driven workflows featuring a Lord of the Rings themed multi-agent system where autonomous agents collaborate to solve problems. | - **Multi-agent Systems**: Creating a network of specialized agents
- **Event-driven Architecture**: Implementing pub/sub messaging between agents
- **Workflow Orchestration**: Coordinating agents through different selection strategies| -| [Multi-Agent Workflow on Kubernetes](https://github.com/dapr/dapr-agents/tree/main/quickstarts/05-multi-agent-workflow-k8s)
Run multi-agent workflows in Kubernetes, demonstrating deployment and orchestration of event-driven agent systems in a containerized environment. | - **Kubernetes Deployment**: Running agents on Kubernetes
- **Container Orchestration**: Managing agent lifecycles with K8s
- **Service Communication**: Inter-agent communication in K8s | -| [Document Agent with Chainlit](https://github.com/dapr/dapr-agents/tree/main/quickstarts/06-document-agent-chainlit)
Create a conversational agent with an operational UI that can upload, and learn unstructured documents while retaining long-term memory. | - **Conversational Document Agent**: Upload and converse over unstructured documents
- **Cloud Agnostic Storage**: Upload files to multiple storage providers
- **Conversation Memory Storage**: Persists conversation history using external storage. | -| [Data Agent with MCP and Chainlit](https://github.com/dapr/dapr-agents/tree/main/quickstarts/08-data-agent-mcp-chainlit)
Build a conversational agent over a Postgres database using Model Composition Protocol (MCP) with a ChatGPT-like interface. | - **Database Querying**: Natural language queries to relational databases
- **MCP Integration**: Connecting to databases without DB-specific code
- **Data Analysis**: Complex data analysis through conversation | diff --git a/daprdocs/content/en/developing-applications/openai-agents/_index.md b/daprdocs/content/en/developing-applications/openai-agents/_index.md deleted file mode 100644 index 978e7c5d54c..00000000000 --- a/daprdocs/content/en/developing-applications/openai-agents/_index.md +++ /dev/null @@ -1,12 +0,0 @@ ---- -type: docs -title: "OpenAI Agents" -linkTitle: "OpenAI Agents" -weight: 25 -description: "Dapr first-class integrations with OpenAI Agents" ---- - -### What is the Dapr OpenAI integration? - -Dapr provides APIs for developers looking to build OpenAI agents that scale and operate reliably in production. Dapr provides first class integrations that range from agent session management to connecting agents via pub/sub and orchestrating agentic workflows. The Dapr OpenAI integration is a Python package that developers can use to augment OpenAI agents with the various Dapr APIs. - \ No newline at end of file diff --git a/daprdocs/content/en/developing-applications/openai-agents/openai-agents-sessions.md b/daprdocs/content/en/developing-applications/openai-agents/openai-agents-sessions.md deleted file mode 100644 index 291cf76ac1d..00000000000 --- a/daprdocs/content/en/developing-applications/openai-agents/openai-agents-sessions.md +++ /dev/null @@ -1,124 +0,0 @@ ---- -type: docs -title: "Agent Sessions" -linkTitle: "Agent Sessions" -weight: 20 -description: "How to use Dapr to reliably and securely manage agent state" ---- - -## Overview - -By using Dapr to manage the state and [session data for OpenAI agents](https://openai.github.io/openai-agents-python/sessions/), users can store agent state in all databases supported by Dapr, including key/value stores, caches and SQL databases. Developers also get built-in tracing, metrics and resiliency policies that make agent session data operate reliably in production. - -## 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 %}} - -### Install Dependencies - -```bash -pip install openai-agents dapr -``` - -### Create an OpenAI Agent - -Let's create a simple OpenAI agent. Put the following in a file named `openai_agent.py`: - -```python -import asyncio -from agents import Agent, Runner -from agents.extensions.memory.dapr_session import DaprSession - -async def main(): - agent = Agent( - name="Assistant", - instructions="Reply very concisely.", - ) - - session = DaprSession.from_address( - session_id="123", - state_store_name="statestore" - ) - - result = await Runner.run(agent, "What city is the Golden Gate Bridge in?", session=session) - print(result.final_output) - - result = await Runner.run(agent, "What state is it in?", session=session) - print(result.final_output) - - result = await Runner.run(agent, "What's the population?", session=session) - print(result.final_output) - -asyncio.run(main()) -``` - -### 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: - -`statestore.yaml`: - -```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: "" -``` - -### Run The Agent - -Now run the local Dapr process and your Python script using the Dapr CLI. - -```bash -dapr run --app-id openaisessions --dapr-grpc-port 50001 --resources-path ./components -- python3 ./openai_agent.py -``` -You can see [the session data stored in Redis]({{% ref "getting-started/get-started-api" %}}#step-4-see-how-the-state-is-stored-in-redis) with the following command - -```bash -hgetall "123:messages" -Open `http://localhost:9411` to view your the traces and dependency graph. - -## Next Steps - -Now that you have an OpenAI 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. - -Read more about OpenAI agent sessions and Dapr [here](https://openai.github.io/openai-agents-python/sessions/). From c4aea88fada5b19663dc4ffbb808901e6559a37c Mon Sep 17 00:00:00 2001 From: Yaron Schneider Date: Mon, 15 Dec 2025 11:08:22 -0800 Subject: [PATCH 12/22] Update daprdocs/content/en/developing-ai/agent-integrations/_index.md Co-authored-by: Casper Nielsen Signed-off-by: Yaron Schneider --- daprdocs/content/en/developing-ai/agent-integrations/_index.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/daprdocs/content/en/developing-ai/agent-integrations/_index.md b/daprdocs/content/en/developing-ai/agent-integrations/_index.md index 9adc139280d..afeaaaa1334 100644 --- a/daprdocs/content/en/developing-ai/agent-integrations/_index.md +++ b/daprdocs/content/en/developing-ai/agent-integrations/_index.md @@ -3,7 +3,7 @@ type: docs title: "Agent Integrations" linkTitle: "Agent Integrations" weight: 25 -description: "Information on how to integrate Dapr with other agentic frameworks and runtime" +description: "Information on how to integrate agentic frameworks with Dapr runtime" --- ### What are Agent Integrations in Dapr? From a11bd212b3c4d9cabbb361c457d10b05b25a4b54 Mon Sep 17 00:00:00 2001 From: Yaron Schneider Date: Mon, 15 Dec 2025 11:09:10 -0800 Subject: [PATCH 13/22] Update daprdocs/content/en/developing-ai/agent-integrations/openai-agents/_index.md Co-authored-by: Casper Nielsen Signed-off-by: Yaron Schneider --- .../en/developing-ai/agent-integrations/openai-agents/_index.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 0c2021a7007..83d119d11d3 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 @@ -3,7 +3,7 @@ type: docs title: "OpenAI Agents" linkTitle: "OpenAI Agents" weight: 25 -description: "Dapr first-class integrations with OpenAI Agents" +description: "Dapr first-class integrations for OpenAI Agents" --- ### What is the Dapr OpenAI Agents integration? From 1f7b378490dffa25dad849098711f29066e1a1fc Mon Sep 17 00:00:00 2001 From: Mark Fussell Date: Mon, 15 Dec 2025 20:18:19 -0800 Subject: [PATCH 14/22] Update daprdocs/content/en/developing-ai/agent-integrations/_index.md Signed-off-by: Mark Fussell --- daprdocs/content/en/developing-ai/agent-integrations/_index.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/daprdocs/content/en/developing-ai/agent-integrations/_index.md b/daprdocs/content/en/developing-ai/agent-integrations/_index.md index afeaaaa1334..0dc825e1748 100644 --- a/daprdocs/content/en/developing-ai/agent-integrations/_index.md +++ b/daprdocs/content/en/developing-ai/agent-integrations/_index.md @@ -6,7 +6,7 @@ weight: 25 description: "Information on how to integrate agentic frameworks with Dapr runtime" --- -### What are Agent Integrations in Dapr? +### What are agent integrations in Dapr? Dapr augments and enhances other agentic frameworks by providing them with key critical features for running in production: From b34f56a575c2e60c8a73b06bf7cfd37316062bc6 Mon Sep 17 00:00:00 2001 From: Mark Fussell Date: Mon, 15 Dec 2025 20:18:32 -0800 Subject: [PATCH 15/22] Update daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-why.md Signed-off-by: Mark Fussell --- .../content/en/developing-ai/dapr-agents/dapr-agents-why.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-why.md b/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-why.md index 125499a3a16..83bb75b30e3 100644 --- a/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-why.md +++ b/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-why.md @@ -102,7 +102,7 @@ Dapr Agents uses a [durable-execution workflow engine]({{% ref workflow-overview Dapr Agents builds on Dapr's Workflow API, which represents each agent as an actor, a single unit of compute and state that is thread-safe and natively distributed. This design enables a scale-to-zero architecture that minimizes infrastructure costs, making AI adoption accessible to organizations of all sizes. The underlying virtual actor model allows thousands of agents to run on demand on a single machine with low latency when scaling from zero. When unused, agents are reclaimed by the system but retain their state until needed again. This design eliminates the trade-off between performance and resource efficiency. -### Data-Centric AI Agents +### Data-centric AI agents With built-in connectivity to over 50 enterprise data sources, Dapr Agents efficiently handles structured and unstructured data. From basic [PDF extraction]({{% ref "/developing-ai/dapr-agents/dapr-agents-integrations.md" %}}) to large-scale database interactions, it enables data-driven AI workflows with minimal code changes. Dapr's [bindings]({{% ref bindings-overview.md %}}) and [state stores]({{% ref supported-state-stores.md %}}), along with MCP support, provide access to numerous data sources for agent data ingestion. From 39acffcde6974ad2ae42446032f157aafd8f17a9 Mon Sep 17 00:00:00 2001 From: Mark Fussell Date: Mon, 15 Dec 2025 20:18:46 -0800 Subject: [PATCH 16/22] Update daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-why.md Signed-off-by: Mark Fussell --- .../content/en/developing-ai/dapr-agents/dapr-agents-why.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-why.md b/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-why.md index 83bb75b30e3..e297fec1adc 100644 --- a/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-why.md +++ b/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-why.md @@ -106,7 +106,7 @@ Dapr Agents builds on Dapr's Workflow API, which represents each agent as an act With built-in connectivity to over 50 enterprise data sources, Dapr Agents efficiently handles structured and unstructured data. From basic [PDF extraction]({{% ref "/developing-ai/dapr-agents/dapr-agents-integrations.md" %}}) to large-scale database interactions, it enables data-driven AI workflows with minimal code changes. Dapr's [bindings]({{% ref bindings-overview.md %}}) and [state stores]({{% ref supported-state-stores.md %}}), along with MCP support, provide access to numerous data sources for agent data ingestion. -### Accelerated Development +### Accelerated development Dapr Agents provides AI features that give developers a complete API surface to tackle common problems, including: From 5570bcd6e6ca30079317123503c7feb354988b42 Mon Sep 17 00:00:00 2001 From: Mark Fussell Date: Mon, 15 Dec 2025 20:18:58 -0800 Subject: [PATCH 17/22] Update daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-introduction.md Signed-off-by: Mark Fussell --- .../en/developing-ai/dapr-agents/dapr-agents-introduction.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-introduction.md b/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-introduction.md index c61cf1f0e2a..2ccaf326724 100644 --- a/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-introduction.md +++ b/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-introduction.md @@ -70,7 +70,7 @@ Get started with Dapr Agents by following the instructions on the [Getting Start Dapr Agents integrates with popular Python frameworks and tools. For detailed integration guides and examples, see the [integrations page]({{% ref "developing-ai/dapr-agents/dapr-agents-integrations.md" %}}). -## Operational Support +## Operational support Dapr Agents inherits Dapr's enterprise-grade operational capabilities, providing comprehensive support for durable and reliable deployments of agentic systems. From df5c3a5d5f75e9a3ef0945b01cfbb900cbf061b3 Mon Sep 17 00:00:00 2001 From: Mark Fussell Date: Mon, 15 Dec 2025 20:19:08 -0800 Subject: [PATCH 18/22] Update daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-introduction.md Signed-off-by: Mark Fussell --- .../en/developing-ai/dapr-agents/dapr-agents-introduction.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-introduction.md b/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-introduction.md index 2ccaf326724..86dffba8cb3 100644 --- a/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-introduction.md +++ b/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-introduction.md @@ -66,7 +66,7 @@ Dapr Agents is a Python framework built on top of the [Python Dapr SDK]({{% ref Get started with Dapr Agents by following the instructions on the [Getting Started page]({{% ref dapr-agents-getting-started.md %}}). -### Framework Integrations +### Framework integrations Dapr Agents integrates with popular Python frameworks and tools. For detailed integration guides and examples, see the [integrations page]({{% ref "developing-ai/dapr-agents/dapr-agents-integrations.md" %}}). From ccf612c4219578e3565cb19c0f76ea56086874a7 Mon Sep 17 00:00:00 2001 From: Yaron Schneider Date: Mon, 15 Dec 2025 20:21:43 -0800 Subject: [PATCH 19/22] Update daprdocs/content/en/developing-ai/agent-integrations/_index.md Co-authored-by: Mark Fussell Signed-off-by: Yaron Schneider --- .../content/en/developing-ai/agent-integrations/_index.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/daprdocs/content/en/developing-ai/agent-integrations/_index.md b/daprdocs/content/en/developing-ai/agent-integrations/_index.md index 0dc825e1748..c1570f915ba 100644 --- a/daprdocs/content/en/developing-ai/agent-integrations/_index.md +++ b/daprdocs/content/en/developing-ai/agent-integrations/_index.md @@ -14,6 +14,10 @@ Dapr augments and enhances other agentic frameworks by providing them with key c * Portable agent context & memory using Dapr's [State Management API]({{% ref "state-management-overview" %}}) * Reliable and secure agent-to-agent communication using [Dapr Pub/Sub]({{% ref "pubsub-overview" %}}) and [Service Invocation ]({{% ref service-invocation-overview %}}) +* Secure agent [identity]({{< ref concepts/security-concept#application-identity >}}) + + + With Dapr, developers writing AI systems using the framework of their choice enjoy accelerated development via the Dapr APIs and gain confidence taking agentic systems into production. \ No newline at end of file From bf37a2d3857e9fd3f1bb58d9f7c1a09b572441c9 Mon Sep 17 00:00:00 2001 From: Yaron Schneider Date: Tue, 16 Dec 2025 14:38:49 -0800 Subject: [PATCH 20/22] Update daprdocs/content/en/developing-ai/_index.md Co-authored-by: Casper Nielsen Signed-off-by: Yaron Schneider --- daprdocs/content/en/developing-ai/_index.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/daprdocs/content/en/developing-ai/_index.md b/daprdocs/content/en/developing-ai/_index.md index 7ebd131d7fe..a0486084ba7 100644 --- a/daprdocs/content/en/developing-ai/_index.md +++ b/daprdocs/content/en/developing-ai/_index.md @@ -2,6 +2,6 @@ type: docs title: "Developing AI with Dapr" linkTitle: "Developing AI" -description: "Information on who to build reliable and secure AI systems with Dapr" +description: "Information on how to build reliable and secure agentic AI systems with Dapr" weight: 31 --- From 1d17e7692e39c524726654d2585908869af0c156 Mon Sep 17 00:00:00 2001 From: yaron2 Date: Tue, 16 Dec 2025 14:44:46 -0800 Subject: [PATCH 21/22] change links Signed-off-by: yaron2 --- .../en/developing-ai/dapr-agents/dapr-agents-quickstarts.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-quickstarts.md b/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-quickstarts.md index f2a519f9a8b..2b64d79bd1c 100644 --- a/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-quickstarts.md +++ b/daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-quickstarts.md @@ -18,11 +18,11 @@ description: "Get started with Dapr Agents through practical step-by-step exampl | Scenario | What You'll Learn | |------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------| | [Hello World](https://github.com/dapr/dapr-agents/tree/main/quickstarts/01-hello-world)
A rapid introduction that demonstrates core Dapr Agents concepts through simple, practical examples. | - **Basic LLM Usage**: Simple text generation with OpenAI models
- **Creating Agents**: Building agents with custom tools in under 20 lines of code

- **Simple Workflows**: Setting up multi-step LLM processes
- **DurableAgent Hosting**: Learn `AgentRunner.run`, `AgentRunner.subscribe`, and `AgentRunner.serve` using the `03_durable_agent_*.py` samples | -| [LLM Call with Dapr Chat Client](https://github.com/dapr/dapr-agents/tree/main/quickstarts/02_llm_call_dapr)
Explore interaction with Language Models through Dapr Agents' `DaprChatClient`, featuring basic text generation with plain text prompts and templates. | - **Text Completion**: Generating responses to prompts
- **Swapping LLM providers**: Switching LLM backends without application code change
- **Resilience**: Setting timeout, retry and circuit-breaking
- **PII Obfuscation**: Automatically detect and mask sensitive user information | -| [LLM Call with OpenAI Client](https://github.com/dapr/dapr-agents/tree/main/quickstarts/02_llm_call_open_ai)
Leverage native LLM client libraries with Dapr Agents using the OpenAI Client for chat completion, audio processing, and embeddings. | - **Text Completion**: Generating responses to prompts
- **Structured Outputs**: Converting LLM responses to Pydantic objects

*Note: Other quickstarts for specific clients are available for [Elevenlabs](https://github.com/dapr/dapr-agents/tree/main/quickstarts/02_llm_call_elevenlabs), [Hugging Face](https://github.com/dapr/dapr-agents/tree/main/quickstarts/02_llm_call_hugging_face), and [Nvidia](https://github.com/dapr/dapr-agents/tree/main/quickstarts/02_llm_call_nvidia).* | +| [LLM Call with Dapr Chat Client](https://github.com/dapr/dapr-agents/tree/main/quickstarts/02-llm-call-dapr)
Explore interaction with Language Models through Dapr Agents' `DaprChatClient`, featuring basic text generation with plain text prompts and templates. | - **Text Completion**: Generating responses to prompts
- **Swapping LLM providers**: Switching LLM backends without application code change
- **Resilience**: Setting timeout, retry and circuit-breaking
- **PII Obfuscation**: Automatically detect and mask sensitive user information | +| [LLM Call with OpenAI Client](https://github.com/dapr/dapr-agents/tree/main/quickstarts/02-llm-call-open-ai)
Leverage native LLM client libraries with Dapr Agents using the OpenAI Client for chat completion, audio processing, and embeddings. | - **Text Completion**: Generating responses to prompts
- **Structured Outputs**: Converting LLM responses to Pydantic objects

*Note: Other quickstarts for specific clients are available for [Elevenlabs](https://github.com/dapr/dapr-agents/tree/main/quickstarts/02-llm-call-elevenlabs), [Hugging Face](https://github.com/dapr/dapr-agents/tree/main/quickstarts/02-llm-call-hugging-face), and [Nvidia](https://github.com/dapr/dapr-agents/tree/main/quickstarts/02-llm-call-nvidia).* | | Standalone & Durable Agents
[Standalone Agent Tool Call](https://github.com/dapr/dapr-agents/tree/main/quickstarts/03-standalone-agent-tool-call) · [Durable Agent Tool Call](https://github.com/dapr/dapr-agents/tree/main/quickstarts/03-durable-agent-tool-call) | - **Standalone Agents**: Build conversational agents with tools in under 20 lines using the `Agent` class
- **Durable Agents**: Upgrade to workflow-backed `DurableAgent` instances with `AgentRunner.run/subscribe/serve`
- **Tool Definition**: Reuse tools with the `@tool` decorator and structured args models
- **Function Calling**: Let LLMs invoke Python functions safely | | [Agentic Workflow](https://github.com/dapr/dapr-agents/tree/main/quickstarts/04-llm-based-workflows)
Dive into stateful workflows with Dapr Agents by orchestrating sequential and parallel tasks through powerful workflow capabilities. | - **LLM-powered Tasks**: Using language models in workflows
- **Task Chaining**: Creating resilient multi-step processes executing in sequence
- **Fan-out/Fan-in**: Executing activities in parallel; then synchronizing these activities until all preceding activities have completed | | [Multi-Agent Workflows](https://github.com/dapr/dapr-agents/tree/main/quickstarts/05-multi-agent-workflows)
Explore advanced event-driven workflows featuring a Lord of the Rings themed multi-agent system where autonomous agents collaborate to solve problems. | - **Multi-agent Systems**: Creating a network of specialized agents
- **Event-driven Architecture**: Implementing pub/sub messaging between agents
- **Workflow Orchestration**: Coordinating agents through different selection strategies| | [Multi-Agent Workflow on Kubernetes](https://github.com/dapr/dapr-agents/tree/main/quickstarts/05-multi-agent-workflow-k8s)
Run multi-agent workflows in Kubernetes, demonstrating deployment and orchestration of event-driven agent systems in a containerized environment. | - **Kubernetes Deployment**: Running agents on Kubernetes
- **Container Orchestration**: Managing agent lifecycles with K8s
- **Service Communication**: Inter-agent communication in K8s | | [Document Agent with Chainlit](https://github.com/dapr/dapr-agents/tree/main/quickstarts/06-document-agent-chainlit)
Create a conversational agent with an operational UI that can upload, and learn unstructured documents while retaining long-term memory. | - **Conversational Document Agent**: Upload and converse over unstructured documents
- **Cloud Agnostic Storage**: Upload files to multiple storage providers
- **Conversation Memory Storage**: Persists conversation history using external storage. | -| [Data Agent with MCP and Chainlit](https://github.com/dapr/dapr-agents/tree/main/quickstarts/08-data-agent-mcp-chainlit)
Build a conversational agent over a Postgres database using Model Composition Protocol (MCP) with a ChatGPT-like interface. | - **Database Querying**: Natural language queries to relational databases
- **MCP Integration**: Connecting to databases without DB-specific code
- **Data Analysis**: Complex data analysis through conversation | +| [Data Agent with MCP and Chainlit](https://github.com/dapr/dapr-agents/tree/main/quickstarts/08-data-agent-mcp-chainlit)
Build a conversational agent over a Postgres database using Model Composition Protocol (MCP) with a ChatGPT-like interface. | - **Database Querying**: Natural language queries to relational databases
- **MCP Integration**: Connecting to databases without DB-specific code
- **Data Analysis**: Complex data analysis through conversation | \ No newline at end of file From 594448fda6efbc0543448858dc14e75a319cadf0 Mon Sep 17 00:00:00 2001 From: yaron2 Date: Tue, 16 Dec 2025 14:48:45 -0800 Subject: [PATCH 22/22] fix ref Signed-off-by: yaron2 --- .../content/en/developing-ai/agent-integrations/_index.md | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/daprdocs/content/en/developing-ai/agent-integrations/_index.md b/daprdocs/content/en/developing-ai/agent-integrations/_index.md index c1570f915ba..7f578a4d80d 100644 --- a/daprdocs/content/en/developing-ai/agent-integrations/_index.md +++ b/daprdocs/content/en/developing-ai/agent-integrations/_index.md @@ -14,10 +14,9 @@ Dapr augments and enhances other agentic frameworks by providing them with key c * Portable agent context & memory using Dapr's [State Management API]({{% ref "state-management-overview" %}}) * Reliable and secure agent-to-agent communication using [Dapr Pub/Sub]({{% ref "pubsub-overview" %}}) and [Service Invocation ]({{% ref service-invocation-overview %}}) -* Secure agent [identity]({{< ref concepts/security-concept#application-identity >}}) - - +* Secure agent [identity]({{< ref "concepts/security-concept" >}}#application-identity) +{{< button text="Install Dapr" page="getting-started.md" >}} With Dapr, developers writing AI systems using the framework of their choice enjoy accelerated development via the Dapr APIs and gain confidence taking agentic systems into production. \ No newline at end of file