dapr · msfussell · Dec 17, 2025 · Dec 10, 2025 · Dec 10, 2025 · Dec 12, 2025
@@ -28,7 +28,7 @@ Dapr provides APIs for communication, state, workflow, and agentic AI. The APIs
       <img src="/images/homepage/dapr-agents.svg" alt="Dapr Agents" width=40>
       <b>Agentic AI</b></h5>
       <p class="card-text">Create durable agentic AI applications with Dapr Agents.</p>
-      <a href="{{% ref "../developing-applications/dapr-agents" %}}" class="stretched-link"></a>
+      <a href="{{% ref "../developing-ai/dapr-agents" %}}" class="stretched-link"></a>
     </div>
   </div>
 </div>

@@ -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

@@ -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 %}})<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 %}})

@@ -0,0 +1,7 @@
+---
+type: docs
+title: "Developing AI with Dapr"
+linkTitle: "Developing AI"
+description: "Information on how to build reliable and secure agentic AI systems with Dapr"
+weight: 31
+---
@@ -0,0 +1,22 @@
+---
+type: docs
+title: "Agent Integrations"
+linkTitle: "Agent Integrations"
+weight: 25
+description: "Information on how to integrate agentic frameworks with Dapr 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 %}})
+* 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.
+
@@ -0,0 +1,12 @@
+---
+type: docs
+title: "OpenAI Agents"
+linkTitle: "OpenAI Agents"
+weight: 25
+description: "Dapr first-class integrations for 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.
+
@@ -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/).
@@ -66,11 +66,11 @@ 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-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
+## Operational support
 
 Dapr Agents inherits Dapr's enterprise-grade operational capabilities, providing comprehensive support for durable and reliable deployments of agentic systems.
 

@@ -25,4 +25,4 @@ description: "Get started with Dapr Agents through practical step-by-step exampl
 | [Multi-Agent Workflows](https://github.com/dapr/dapr-agents/tree/main/quickstarts/05-multi-agent-workflows)<br>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 <br> - **Event-driven Architecture**: Implementing pub/sub messaging between agents <br> - **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)<br>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 <br> - **Container Orchestration**: Managing agent lifecycles with K8s <br> - **Service Communication**: Inter-agent communication in K8s |
 | [Document Agent with Chainlit](https://github.com/dapr/dapr-agents/tree/main/quickstarts/06-document-agent-chainlit)<br>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 <br> - **Cloud Agnostic Storage**: Upload files to multiple storage providers <br> - **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)<br>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 <br> - **MCP Integration**: Connecting to databases without DB-specific code <br> - **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)<br>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 <br> - **MCP Integration**: Connecting to databases without DB-specific code <br> - **Data Analysis**: Complex data analysis through conversation |
@@ -102,11 +102,11 @@ 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-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
+### Accelerated development
 
 Dapr Agents provides AI features that give developers a complete API surface to tackle common problems, including:
 

@@ -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 %}})