Add OpenAI integration docs

daprdocs/content/en/_index.md

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

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

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

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

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 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 %}})
+
+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.
+

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 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.
+

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/).

daprdocs/content/en/developing-applications/dapr-agents/dapr-agents-introduction.md → 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
 

daprdocs/content/en/developing-applications/dapr-agents/dapr-agents-quickstarts.md → daprdocs/content/en/developing-ai/dapr-agents/dapr-agents-quickstarts.md

@@ -18,8 +18,8 @@ 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)<br>A rapid introduction that demonstrates core Dapr Agents concepts through simple, practical examples.                                                                                    | - **Basic LLM Usage**: Simple text generation with OpenAI models <br> - **Creating Agents**: Building agents with custom tools in under 20 lines of code <br> <br> - **Simple Workflows**: Setting up multi-step LLM processes <br> - **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)<br>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 <br> - **Swapping LLM providers**: Switching LLM backends without application code change <br> - **Resilience**: Setting timeout, retry and circuit-breaking <br> - **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)<br>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 <br> - **Structured Outputs**: Converting LLM responses to Pydantic objects <br><br> *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)<br>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 <br> - **Swapping LLM providers**: Switching LLM backends without application code change <br> - **Resilience**: Setting timeout, retry and circuit-breaking <br> - **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)<br>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 <br> - **Structured Outputs**: Converting LLM responses to Pydantic objects <br><br> *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 <br> [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 <br> - **Durable Agents**: Upgrade to workflow-backed `DurableAgent` instances with `AgentRunner.run/subscribe/serve` <br> - **Tool Definition**: Reuse tools with the `@tool` decorator and structured args models <br> - **Function Calling**: Let LLMs invoke Python functions safely |
 | [Agentic Workflow](https://github.com/dapr/dapr-agents/tree/main/quickstarts/04-llm-based-workflows)<br>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 <br> - **Task Chaining**: Creating resilient multi-step processes executing in sequence <br> - **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)<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|

daprdocs/content/en/developing-applications/dapr-agents/dapr-agents-why.md → 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
 

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