Repository: airtai/fastagency

Issue:
Update FastAPI + NATS.io adapter section with custom HTML/JS client implementation

Discussion:
codecov[bot]: ## [Codecov](https://app.codecov.io/gh/airtai/fastagency/pull/461?dropdown=coverage&src=pr&el=h1&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=airtai) Report
Attention: Patch coverage is `88.88889%` with `1 line` in your changes missing coverage. Please review.

| [Files with missing lines](https://app.codecov.io/gh/airtai/fastagency/pull/461?dropdown=coverage&src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=airtai) | Patch % | Lines |
|---|---|---|
| [...ted/nats\_n\_fastapi/main\_2\_fastapi\_custom\_client.py](https://app.codecov.io/gh/airtai/fastagency/pull/461?src=pr&el=tree&filepath=docs%2Fdocs_src%2Fgetting_started%2Fnats_n_fastapi%2Fmain_2_fastapi_custom_client.py&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=airtai#diff-ZG9jcy9kb2NzX3NyYy9nZXR0aW5nX3N0YXJ0ZWQvbmF0c19uX2Zhc3RhcGkvbWFpbl8yX2Zhc3RhcGlfY3VzdG9tX2NsaWVudC5weQ==) | 88.88% | [1 Missing :warning: ](https://app.codecov.io/gh/airtai/fastagency/pull/461?src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=airtai) |

| [Files with missing lines](https://app.codecov.io/gh/airtai/fastagency/pull/461?dropdown=coverage&src=pr&el=tree&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=airtai) | Coverage Δ | |
|---|---|---|
| [...ting\_started/fastapi/main\_fastapi\_custom\_client.py](https://app.codecov.io/gh/airtai/fastagency/pull/461?src=pr&el=tree&filepath=docs%2Fdocs_src%2Fgetting_started%2Ffastapi%2Fmain_fastapi_custom_client.py&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=airtai#diff-ZG9jcy9kb2NzX3NyYy9nZXR0aW5nX3N0YXJ0ZWQvZmFzdGFwaS9tYWluX2Zhc3RhcGlfY3VzdG9tX2NsaWVudC5weQ==) | `62.50% <ø> (ø)` | |
| [...ted/nats\_n\_fastapi/main\_2\_fastapi\_custom\_client.py](https://app.codecov.io/gh/airtai/fastagency/pull/461?src=pr&el=tree&filepath=docs%2Fdocs_src%2Fgetting_started%2Fnats_n_fastapi%2Fmain_2_fastapi_custom_client.py&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=airtai#diff-ZG9jcy9kb2NzX3NyYy9nZXR0aW5nX3N0YXJ0ZWQvbmF0c19uX2Zhc3RhcGkvbWFpbl8yX2Zhc3RhcGlfY3VzdG9tX2NsaWVudC5weQ==) | `88.88% <88.88%> (ø)` | |

... and [2 files with indirect coverage changes](https://app.codecov.io/gh/airtai/fastagency/pull/461/indirect-changes?src=pr&el=tree-more&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=airtai)


Patch:
diff --git a/.gitattributes b/.gitattributes
index c1aa6991..bdfa710e 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1,7 +1,6 @@
 *.jpg filter=lfs diff=lfs merge=lfs -text
 *.png filter=lfs diff=lfs merge=lfs -text
 *.pdf filter=lfs diff=lfs merge=lfs -text
-*.png filter=lfs diff=lfs merge=lfs -text
 app/public/public-banner.png filter=lfs diff=lfs merge=lfs -text
 docs/docs/en/tutorial/giphy/images/gifs.png filter=lfs diff=lfs merge=lfs -text
 docs/docs/en/tutorial/giphy/images/initial_message.png filter=lfs diff=lfs merge=lfs -text
diff --git a/.secrets.baseline b/.secrets.baseline
index 6e1e66e8..4605ece1 100644
--- a/.secrets.baseline
+++ b/.secrets.baseline
@@ -168,7 +168,7 @@
         "filename": "docs/docs/en/user-guide/adapters/fastapi_nats/index.md",
         "hashed_secret": "3be2e9dd1980856faddf5bd205e3ff96b24776aa",
         "is_verified": false,
-        "line_number": 173,
+        "line_number": 287,
         "is_secret": false
       }
     ],
@@ -178,7 +178,27 @@
         "filename": "docs/docs/en/user-guide/adapters/nats/index.md",
         "hashed_secret": "3be2e9dd1980856faddf5bd205e3ff96b24776aa",
         "is_verified": false,
-        "line_number": 144,
+        "line_number": 140,
+        "is_secret": false
+      }
+    ],
+    "docs/docs/en/user-guide/runtimes/autogen/index.md": [
+      {
+        "type": "Secret Keyword",
+        "filename": "docs/docs/en/user-guide/runtimes/autogen/index.md",
+        "hashed_secret": "73b01af8d354687c7c330d91a744f9906b9f30da",
+        "is_verified": false,
+        "line_number": 46,
+        "is_secret": false
+      }
+    ],
+    "docs/docs/en/user-guide/runtimes/autogen/using_non_openai_models.md": [
+      {
+        "type": "Secret Keyword",
+        "filename": "docs/docs/en/user-guide/runtimes/autogen/using_non_openai_models.md",
+        "hashed_secret": "29df8e701c64566b0035b6283fb2f7b41a0d65f2",
+        "is_verified": false,
+        "line_number": 55,
         "is_secret": false
       }
     ],
diff --git a/docs/docs/en/getting-started/index.md b/docs/docs/en/getting-started/index.md
index e5c8d4c6..dcdb2456 100644
--- a/docs/docs/en/getting-started/index.md
+++ b/docs/docs/en/getting-started/index.md
@@ -393,11 +393,11 @@ Once everything is set up, you can run your FastAgency application using the fol
             ```
 
         !!! danger "Currently not working on **MacOS**"
-            The above command is currently not working on **MacOS**, please use the alternative way of starting the application from below ([#362](https://github.com/airtai/fastagency/issues/362)).
+            The above command is currently not working on **MacOS**, please use the alternative way of starting the application from below ([#362](https://github.com/airtai/fastagency/issues/362){target="_blank"}).
 
     2. Using [Gunicorn](https://gunicorn.org/){target="_blank"} WSGI HTTP server:
 
-        The preferred way to run the Mesop application is using a Python WSGI HTTP server like [Gunicorn](https://gunicorn.org/){target="_blank"}. First, you need to install it using package manager such as `pip` and then run it as follows:
+        The preferred way to run the [**Mesop**](https://google.github.io/mesop/){target="_blank"} application is using a Python WSGI HTTP server like [**Gunicorn**](https://gunicorn.org/){target="_blank"}. First, you need to install it using package manager such as `pip` and then run it as follows:
 
         !!! note "Terminal (using [Gunicorn](https://gunicorn.org/){target="_blank"})"
             ```
diff --git a/docs/docs/en/tutorial/giphy/index.md b/docs/docs/en/tutorial/giphy/index.md
index e259ba3d..e8898588 100644
--- a/docs/docs/en/tutorial/giphy/index.md
+++ b/docs/docs/en/tutorial/giphy/index.md
@@ -170,11 +170,11 @@ There are two options of running a Mesop application:
         ```
 
     !!! danger "Currently not working on **MacOS**"
-        The above command is currently not working on **MacOS**, please use the alternative way of starting the application from below ([#362](https://github.com/airtai/fastagency/issues/362)).
+        The above command is currently not working on **MacOS**, please use the alternative way of starting the application from below ([#362](https://github.com/airtai/fastagency/issues/362){target="_blank"}).
 
 2. Using [Gunicorn](https://gunicorn.org/){target="_blank"} WSGI HTTP server:
 
-    The preferred way to run the Mesop application is using a Python WSGI HTTP server like [Gunicorn](https://gunicorn.org/){target="_blank"}. First, you need to install it using package manager such as `pip` and then run it as follows:
+    The preferred way to run the [**Mesop**](https://google.github.io/mesop/){target="_blank"} application is using a Python WSGI HTTP server like [**Gunicorn**](https://gunicorn.org/){target="_blank"}. First, you need to install it using package manager such as `pip` and then run it as follows:
 
     !!! note "Terminal (using [Gunicorn](https://gunicorn.org/){target="_blank"})"
         ```
diff --git a/docs/docs/en/user-guide/adapters/fastapi/index.md b/docs/docs/en/user-guide/adapters/fastapi/index.md
index b9d96f39..65ee2cac 100644
--- a/docs/docs/en/user-guide/adapters/fastapi/index.md
+++ b/docs/docs/en/user-guide/adapters/fastapi/index.md
@@ -1,87 +1,87 @@
 # FastAPI
 
-The **FastAPI Adapter** allows you to expose your FastAgency workflows as a REST API using the [**FastAPI**](https://fastapi.tiangolo.com/){target="_blank"} framework.
+The [**`FastAPIAdapter`**](../../../api/fastagency/adapters/fastapi/FastAPIAdapter.md) allows you to expose your FastAgency workflows as a [**REST API**](https://en.wikipedia.org/wiki/REST){target="_blank"} using the [**FastAPI**](https://fastapi.tiangolo.com/){target="_blank"} framework.
 
 ## Use Cases
 
-This section outlines the scenarios where it's particularly beneficial to use the [**`FastAPIAdapter`**](../../../api/fastagency/adapters/fastapi/FastAPIAdapter.md).
+When to Use the [**`FastAPIAdapter`**](../../../api/fastagency/adapters/fastapi/FastAPIAdapter.md):
 
-### When to Use the FastAPI Adapter
+- **Custom Client Applications**: If you want to build your **own client applications** in a language other than Python, (e.g., [**HTML**](https://en.wikipedia.org/wiki/HTML){target="_blank"}/[**JavaScript**](https://en.wikipedia.org/wiki/JavaScript){target="_blank"}), that interacts with your FastAgency workflows using [**REST API**](https://en.wikipedia.org/wiki/REST){target="_blank"} and [**WebSockets**](https://en.wikipedia.org/wiki/WebSocket){target="_blank"}.
 
-- **Custom Client Applications**: If you want to build your **own client applications** that interact with your FastAgency workflows using REST APIs, this adapter provides greater flexibility and control over the client-side implementation.
-- **Moderate User Demand**: The FastAPI Adapter is a good fit for scenarios with **moderate user request volume**. For example, it's well-suited for a medium-sized company developing an internal custom chat application.
-- **Simplified Production Setup**: Choose this adapter if you need a **simple and easy-to-manage** production setup for deploying your FastAgency workflows as a REST API.
+- **Moderate User Demand**: This adapter is a good fit for scenarios where workflows need to be executed by [**multiple workers**](https://fastapi.tiangolo.com/deployment/server-workers/){target="_blank"} to efficiently handle higher machine load.
 
+- **Simplified Production Setup**: This adapter is a good choice when you need a **simple and easy-to-manage** setup for [**deploying**](https://fastapi.tiangolo.com/deployment/){target="_blank"} FastAgency workflows as an [**ASGI**](https://asgi.readthedocs.io/en/latest/){target="_blank"} server in production.
 
 ## Architecture Overview
 
-The following section presents high-level architecture diagrams for the two available setups:
+This section provides [**high-level architecture**](https://en.wikipedia.org/wiki/High-level_design){target="_blank"} diagrams for the two available setups of using [**FastAPI**](https://fastapi.tiangolo.com/){target="_blank"} with:
 
-- **FastAPI with Mesop Client**
-- **FastAPI with Custom Client**
+- [**Mesop**](https://google.github.io/mesop/){target="_blank"} client using [**`MesopUI`**](../../../api/fastagency/ui/mesop/MesopUI.md), and
 
-=== "FastAPI with Mesop Client"
+- Custom [**REST API**](https://en.wikipedia.org/wiki/REST){target="_blank"} and [**WebSocket**](https://en.wikipedia.org/wiki/WebSocket){target="_blank"} client
+
+=== "Mesop"
 
     ![Mesop FastAPI App](../images/mesop_fastapi.png)
 
     The system consists of two main components:
 
-    ### FastAgency Client App
+    #### Mesop Client App
 
-    The FastAgency Client App serves as the frontend interface for the system. It includes:
+    The client App serves as the frontend interface for the system. It includes:
 
-    - **Mesop Client**: A friendly web interface for users to interact with the workflows. It facilitates the communication with the user and the FastAPI Provider.
-    - **FastAPI Provider**: A component that facilitates communication between the Mesop client and the FastAPI Adapter.
+    - [**`MesopUI`**](../../../api/fastagency/ui/mesop/MesopUI.md): A friendly web interface for users to interact with the workflows. It facilitates the communication with the user and the **`FastAPIProvider`**.
+    - [**`FastAPIProvider`**](../../../api/fastagency/adapters/fastapi/FastAPIProvider.md): A component that facilitates communication between the Mesop client and the [**`FastAPIAdapter`**](../../../api/fastagency/adapters/fastapi/FastAPIAdapter.md).
 
     This app handles all client interactions and presents the results back to the user.
 
-    ### FastAgency FastAPI App
+    #### FastAPI App
 
-    The FastAgency FastAPI App forms the backend of our system and consists of:
+    The FastAPI App forms the backend of our system and consists of:
 
     - **AutoGen Workflows**: These define the core logic and behavior of our application, utilizing agents to perform various tasks and achieve specific goals.
-    - **FastAPI Adapter**: This component communicates with AutoGen, and implements routes and websocket for FastAPI.
-    - **FastAPI**: Provides the infrastructure for building and exposing AutoGen workflows via REST API.
+    - The [**`FastAPIAdapter`**](../../../api/fastagency/adapters/fastapi/FastAPIAdapter.md): This component communicates with AutoGen, and implements routes and websocket for FastAPI.
+    - [**FastAPI**](https://fastapi.tiangolo.com/){target="_blank"}: Provides the infrastructure for building and exposing AutoGen workflows via REST API.
 
-    ### Interaction Flow
+    #### Interaction Flow
 
-    1. The user initiates communication with the Mesop client in the FastAgency Client App.
+    1. The user initiates communication with the Mesop client in the client App.
     2. The Mesop client interacts with the FastAPI Provider, sending requests based on user actions.
-    3. The FastAPI Provider communicates these requests to the FastAPI Adapter in the FastAgency FastAPI App.
+    3. The FastAPI Provider communicates these requests to the FastAPI Adapter in the FastAPI App.
     4. The FastAPI Adapter processes the requests and triggers the appropriate AutoGen workflows.
     5. The AutoGen workflows execute, performing the required tasks and generating results.
     6. Results are sent back through the FastAPI Adapter to the FastAPI Provider.
     7. The FastAPI Provider relays the results to the Mesop client, which then presents them to the user.
 
-=== "FastAPI with Custom Client"
+=== "Custom REST API and Websocket"
 
     ![Custom FastAPI App](../images/custom_fastapi.png)
 
     The system consists of two main components:
 
-    ### FastAgency Client App
+    #### Client App
 
-    The FastAgency Client App serves as the frontend interface for the system. It includes:
+    The Client App serves as the frontend interface for the system. It includes:
 
-    - **Custom Client**: A custom web interface for users to interact with the workflows. It facilitates the communication with the user and the **FastAgency FastAPI App**.
+    - **Custom Client**: A custom web interface for users to interact with the workflows. It facilitates the communication with the user and the **FastAPI App**.
 
-    This custom client app handles all interactions with the **FastAgency FastAPI App** and presents the results back to the user.
+    This custom client app handles all interactions with the **FastAPI App** and presents the results back to the user.
 
-    ### FastAgency FastAPI App
+    #### FastAPI App
 
-    The FastAgency FastAPI App forms the backend of our system and consists of:
+    The FastAPI App forms the backend of our system and consists of:
 
     - **AutoGen Workflows**: These define the core logic and behavior of our application, utilizing agents to perform various tasks and achieve specific goals.
-    - **FastAPI Adapter**: This component communicates with AutoGen, and implements routes and websocket for FastAPI.
-    - **FastAPI**: Provides the infrastructure for building and exposing AutoGen workflows via REST API.
+    - [**`FastAPIAdapter`**](../../../api/fastagency/adapters/fastapi/FastAPIAdapter.md): This component communicates with AutoGen, and implements routes and websocket for FastAPI.
+    - [**FastAPI**](https://fastapi.tiangolo.com/){target="_blank"}: Provides the infrastructure for building and exposing AutoGen workflows via REST API.
 
-    ### Building Custom Client Applications
+    #### Building Custom Client Applications
 
-    To write a custom application that interacts with FastAgency FastAPI App, we first need to understand the **available server routes** and their purposes. This knowledge forms the foundation of our client-server interaction model.
+    To write a custom application that interacts with FastAPI App, we first need to understand the **available server routes** and their purposes. This knowledge forms the foundation of our client-server interaction model.
 
-    #### Available API Endpoints
+    ##### Available API Endpoints
 
-    FastAgency FastAPI App provides three primary endpoints for building client applications:
+    FastAPI App provides three primary endpoints for building client applications:
 
     | Route    | Method |Purpose |
     | -------- | ------- | ------- |
@@ -92,14 +92,14 @@ The following section presents high-level architecture diagrams for the two avai
 
     Now that we understand the available routes, let's visualize how these components interact in a typical client-server communication flow.
 
-    #### System Interaction Flow
+    ##### System Interaction Flow
 
     The following sequence diagram illustrates the step-by-step process of how a **custom client application** interacts with the FastAgency FastAPI server:
 
     ```mermaid
     sequenceDiagram
     participant Client as Custom Client Application
-    participant FastAPI as FastAgency FastAPI App
+    participant FastAPI as FastAPI App
 
     Note over Client,FastAPI: 1. Setup & Discovery Phase
     Client->>FastAPI: GET /fastagency/discovery
@@ -131,7 +131,7 @@ The following section presents high-level architecture diagrams for the two avai
 
     To better understand this diagram, let's break down the key steps involved in the client-server interaction:
 
-    #### Understanding the Flow
+    ##### Understanding the Flow
 
     The interaction between client and server follows these key steps:
 
@@ -144,7 +144,7 @@ The following section presents high-level architecture diagrams for the two avai
         - Server processes and sends the next workflow message
 
 
-    #### Message Types
+    ##### Message Types
 
     Before diving into the implementation, we need to learn a bit about the **message types** that FastAgency FastAPI adapter provides. Understanding these will help us handle messages in our custom client and display them properly to the users.
 
@@ -166,9 +166,9 @@ The following section presents high-level architecture diagrams for the two avai
 
     A full list of message types and their detailed usage will be **available soon in the FastAgency Adapter’s OpenAPI specification**—stay tuned!
 
-    #### Implementation Guide
+    ##### Implementation Guide
 
-    In the following sections, we'll walk through the process of creating a custom client application that implements the flow we've just described. We'll build a simple web-based client that demonstrates how to interact with **FastAgency FastAPI App** effectively.
+    In the following sections, we'll walk through the process of creating a custom client application that implements the flow we've just described. We'll build a simple web-based client that demonstrates how to interact with **FastAPI App** effectively.
 
     Our implementation will cover these key aspects:
 
@@ -181,7 +181,7 @@ The following section presents high-level architecture diagrams for the two avai
 
         Before we examine the code:
 
-        - The below example uses a **simple HTML with JavaScript**, all in a single string and served directly from the FastAgency FastAPI app for **simplicity**.
+        - The below example uses a **simple HTML with JavaScript**, all in a single string and served directly from the FastAPI App for **simplicity**.
         - This approach is **not suitable for production** but ideal for demonstrating core concepts.
         - In a real-world scenario, you'd use a separate frontend, built with frameworks like React or Vue.js, or other languages such as Java, Go, or Ruby, based on your project needs.
 
@@ -191,7 +191,7 @@ The following section presents high-level architecture diagrams for the two avai
 
 Before getting started, make sure you have installed FastAgency by running the following command:
 
-=== "FastAPI with Mesop Client"
+=== "Mesop"
 
     ```bash
     pip install "fastagency[autogen,mesop,fastapi,server]"
@@ -199,7 +199,7 @@ Before getting started, make sure you have installed FastAgency by running the f
 
     This command installs FastAgency with support for both the Console and Mesop interfaces for AutoGen workflows, but with FastAPI serving input requests and running workflows.
 
-=== "FastAPI with Custom Client"
+=== "Custom REST API and Websocket"
 
     ```bash
     pip install "fastagency[autogen,fastapi,server]"
@@ -209,11 +209,11 @@ Before getting started, make sure you have installed FastAgency by running the f
 
 ## Example: Student and Teacher Learning Chat
 
-=== "FastAPI with Mesop Client"
+=== "Mesop"
 
     In this example, we'll create a simple learning chat where a student agent asks questions and a teacher agent responds, simulating a learning environment. We'll use MesopUI for the web interface and the FastAPI Adapter to expose the workflow as a REST API.
 
-=== "FastAPI with Custom Client"
+=== "Custom REST API and Websocket"
 
     In this example, we'll create a simple learning chat where a student agent asks questions and a teacher agent responds, simulating a learning environment. We'll create a custom client for the web interface and the FastAPI Adapter to expose the workflow as a REST API.
 
@@ -221,7 +221,7 @@ Before getting started, make sure you have installed FastAgency by running the f
 
 #### 1. **Import Required Modules**
 
-=== "FastAPI with Mesop Client"
+=== "Mesop"
 
     To get started, import the required modules from the **FastAgency** and **AutoGen**. These imports provide the essential building blocks for creating agents, workflows, and integrating MesopUI. Additionally, import the [**`FastAPIAdapter`**](../../../api/fastagency/adapters/fastapi/FastAPIAdapter.md) class to expose the workflows as a REST API.
 
@@ -229,12 +229,12 @@ Before getting started, make sure you have installed FastAgency by running the f
     {!> docs_src/getting_started/fastapi/main_1_fastapi.py [ln:1-9] !}
     ```
 
-=== "FastAPI with Custom Client"
+=== "Custom REST API and Websocket"
 
     To get started, import the required modules from the **FastAgency** and **AutoGen**. These imports provide the essential building blocks for creating agents, workflows, and integrating with the Custom client. Additionally, import the [**`FastAPIAdapter`**](../../../api/fastagency/adapters/fastapi/FastAPIAdapter.md) and [**`HTMLResponse`**](https://fastapi.tiangolo.com/advanced/custom-response/#html-response){target="_blank"} class to expose the workflows as a REST API.
 
     ```python hl_lines="6 9"
-    {!> docs_src/getting_started/fastapi/main_custom_fastapi_client.py [ln:1-10] !}
+    {!> docs_src/getting_started/fastapi/main_fastapi_custom_client.py [ln:1-10] !}
     ```
 
 #### 2. **Define Workflow**
@@ -253,7 +253,7 @@ Create an instance of the [**`FastAPIAdapter`**](../../../api/fastagency/adapter
 {!> docs_src/getting_started/fastapi/main_1_fastapi.py [ln:55-58] !}
 ```
 
-=== "FastAPI with Mesop Client"
+=== "Mesop"
 
     #### 4. **Adapter Chaining**
 
@@ -264,21 +264,21 @@ Create an instance of the [**`FastAPIAdapter`**](../../../api/fastagency/adapter
         {!> docs_src/getting_started/fastapi/main_2_mesop.py [ln:1-11] !}
         ```
 
-=== "FastAPI with Custom Client"
+=== "Custom REST API and Websocket"
 
     #### 4. **Serving the Custom HTML Client**
 
     Finally, use the HTML Response from FastAPI to serve the custom client code.
 
     ```python
-    {!> docs_src/getting_started/fastapi/main_custom_fastapi_client.py [ln:12-98,146-148] !}
+    {!> docs_src/getting_started/fastapi/main_fastapi_custom_client.py [ln:12-98,146-148] !}
     ```
 
 ### Complete Application Code
 
 Please copy and paste the following code into the same folder, using the file names exactly as mentioned below.
 
-=== "FastAPI with Mesop Client"
+=== "Mesop"
 
     <details>
         <summary>main_1_fastapi.py</summary>
@@ -294,18 +294,18 @@ Please copy and paste the following code into the same folder, using the file na
         ```
     </details>
 
-=== "FastAPI with Custom Client"
+=== "Custom REST API and Websocket"
 
     <details>
-        <summary>main_custom_fastapi_client.py</summary>
+        <summary>main_fastapi_custom_client.py</summary>
         ```python
-        {!> docs_src/getting_started/fastapi/main_custom_fastapi_client.py !}
+        {!> docs_src/getting_started/fastapi/main_fastapi_custom_client.py !}
         ```
     </details>
 
 ### Run Application
 
-=== "FastAPI with Mesop Client"
+=== "Mesop"
 
     Once everything is set up, you can run your FastAgency application using the following commands. You need to run **two** commands in **separate** terminal windows:
 
@@ -327,21 +327,21 @@ Please copy and paste the following code into the same folder, using the file na
         waitress-serve --listen=0.0.0.0:8888 main_2_mesop:app
         ```
 
-=== "FastAPI with Custom Client"
+=== "Custom REST API and Websocket"
 
     Once everything is set up, you can run your FastAgency application using the following command.
 
     - Start **FastAPI** application using uvicorn:
     !!! note "Terminal 1"
         ```
-        uvicorn main_custom_fastapi_client:app --host 0.0.0.0 --port 8008 --reload
+        uvicorn main_fastapi_custom_client:app --host 0.0.0.0 --port 8008 --reload
         ```
 
 ### Output
 
 The outputs will vary based on the interface. Here is the output of the last terminal starting the UI:
 
-=== "FastAPI with Mesop Client"
+=== "Mesop"
 
     ```console
     [2024-10-10 13:19:18 +0530] [23635] [INFO] Starting gunicorn 23.0.0
@@ -352,7 +352,7 @@ The outputs will vary based on the interface. Here is the output of the last ter
 
     ![Output Screenshot](../../../getting-started/images/chat.png)
 
-=== "FastAPI with Custom Client"
+=== "Custom REST API and Websocket"
 
     ```console
     INFO:     Will watch for changes in these directories: ['/tmp/custom_fastapi_demo']
diff --git a/docs/docs/en/user-guide/adapters/fastapi_nats/index.md b/docs/docs/en/user-guide/adapters/fastapi_nats/index.md
index 2c763c8f..8565a3f0 100644
--- a/docs/docs/en/user-guide/adapters/fastapi_nats/index.md
+++ b/docs/docs/en/user-guide/adapters/fastapi_nats/index.md
@@ -1,6 +1,6 @@
 # FastAPI + Nats.io
 
-The **FastAPI + Nats.io** Adapter in FastAgency offers the most scalable setup by combining the power of the [**FastAPI**](https://fastapi.tiangolo.com/){target="_blank"} framework for building and exposing workflows as **REST APIs** with the [**Nats.io MQ**](https://nats.io/){target="_blank"} message broker for **scalable and asynchronous** communication. This setup is the **preferred way** for running large workloads in production.
+The **FastAPI + Nats.io** Adapter in FastAgency offers the most scalable setup by combining the power of the [**FastAPI**](https://fastapi.tiangolo.com/){target="_blank"} framework for building and exposing workflows as [**REST APIs**](https://en.wikipedia.org/wiki/REST){target="_blank"} with the [**Nats.io MQ**](https://nats.io/){target="_blank"} message broker for **scalable and asynchronous** communication. This setup is the **preferred way** for running large workloads in production.
 
 ## Use Cases
 
@@ -8,73 +8,131 @@ This section outlines the scenarios where it's particularly beneficial to use th
 
 ### When to Use the FastAPI + Nats.io Adapter
 
-- **Custom Client Applications**: If you want to build your **own client applications** that interact with your FastAgency workflows using REST APIs, this adapter provides greater flexibility and control over the client-side implementation.
-- **High User Demand**: When your application needs to handle a large number of users or messages and requires high scalability, the FastAPI + Nats Adapter is an excellent choice. It is well-suited for building **scalable custom chat applications for larger companies or external customers**.
-- **Conversation Auditing**: If you need the ability to **audit conversations**, the Nats Adapter provides the necessary infrastructure to enable this feature.
+- **High User Demand**: If you need to scale above what can be achieved with multiple-workers of the [**FastAPI** adapter](../fastapi/index.md), then you can use [**Nats.io MQ**](https://nats.io/){target="_blank"}-based message que and multiple workers consuming and producing messages. This kind of distributed, [message-queue architecture](https://en.wikipedia.org/wiki/Message_queue){target="_blank"} allows you to scale up not just across multiple workers, but also across multiple machines and even across multiple clusters.
 
+- **Observability**: If you need the ability to **audit workflow executions** both in realtime and posteriori, the Nats Adapter provides the necessary infrastructure to enable this feature.
+
+- Security features of FastAPI (links etc.)
 
 ## Architecture Overview
 
-The following diagram illustrates the high-level architecture of an application using the  **FastAPI + Nats Adapter**:
+The following section presents high-level architecture diagrams for the two available setups:
+
+- **FastAPI + Nats Adapter with Mesop Client**
+- **FastAPI + Nats Adapter with Custom Client**
+
+=== "FastAPI + Nats Adapter with Mesop Client"
+
+    ![Mesop FastAPI](../images/mesop_fastapi_nats.png)
+
+    The system is composed of three main components:
+
+    #### 1. FastAgency Client App
+
+    The FastAgency Client App serves as the frontend interface for the system. It includes:
+
+    - **Mesop Client**: A friendly web interface for users to interact with the workflows. It facilitates the communication with the user and the FastAPI Provider.
+    - **FastAPI Provider**: A component that facilitates communication between the Mesop client and the FastAPI Adapter.
+
+    This app handles all client interactions and presents the results back to the user.
 
-![Mesop FastAPI](../images/mesop_fastapi_nats.png)
+    #### 2. FastAgency FastAPI App
 
-The system is composed of three main components:
+    The FastAgency FastAPI App forms the backend of our system and consists of:
 
-### FastAgency Client App
+    - **Nats Provider**: Responsible for connecting to the Nats Provider, receiving workflow initiation messages, and distributing them to the workers for execution.
+    - **FastAPI Adapter**: This component communicates with AutoGen, and implements routes and websocket for FastAPI.
+    - **FastAPI**: Provides the infrastructure for building and exposing AutoGen workflows via REST API.
 
-The FastAgency Client App serves as the frontend interface for the system. It includes:
+    #### 3. FastAgency Nats App
+    - **Nats Adapter**: This adapter connects to the Nats Provider. Its primary responsibility is to receive workflow initiation messages and delegate them to available workers for execution.
+    - **AutoGen Workflows**: These workflows, defined using the AutoGen framework, embody the core logic and behavior of your application. They leverage agents to perform various tasks and accomplish specific goals.
 
-- **Mesop UI or Custom UI**: A web interface for users to interact with the workflows. It facilitates the communication with the client and the FastAPI Provider.
-- **FastAPI Provider**: This component acts as a bridge, facilitating seamless communication between the Mesop UI and the FastAPI Adapter.
+    #### Interaction Flow
+    1. The user initiates communication with the Mesop client in the FastAgency Client App.
+    2. The Mesop client relays requests, based on user actions, to the FastAPI Provider.
+    3. The FastAPI Provider forwards these requests to the FastAPI Adapter in the FastAgency FastAPI App.
+    4. The FastAPI Adapter processes the requests and sends a message to the Nats Provider to start the workflow.
+    5. The Nats Adapter, connected to the Nats Provider, receives the workflow initiation message.
+    6. The Nats Adapter distributes the task of executing the workflow to one of the available workers.
+    7. The designated worker executes the AutoGen Workflow and sends the results back through the Nats Provider to the FastAPI Adapter.
+    8. The FastAPI Adapter sends the results to the FastAPI Provider, which relays them to the Mesop client for presentation to the client.
 
-The FastAgency Client App manages all client interactions, handling requests and presenting the results back to the user.
+    This architecture promotes a clear separation of concerns between the user interface, the API layer, and the workflow execution logic, enhancing modularity and maintainability. The FastAPI framework provides a user-friendly and efficient API, while the Nats Adapter, coupled with the Nats.io MQ message broker, ensures scalability and asynchronous communication.
 
-### FastAgency FastAPI App
+=== "FastAPI + Nats Adapter with Custom Client"
 
-The FastAgency FastAPI App forms the backend of our system and consists of:
+    ![Mesop FastAPI](../images/custom_fastapi_nats.png)
 
-- **Nats Provider**: Responsible for connecting to the Nats Provider, receiving workflow initiation messages, and distributing them to the workers for execution.
-- **FastAPI Adapter**: This component receives requests from the FastAPI Provider and communicates with NatsProvider, and implements routes and WebSocket for FastAPI.
-- **FastAPI**: Provides the infrastructure for building and exposing AutoGen workflows via REST API.
+    The system is composed of three main components:
 
-### FastAgency Nats App
-- **Nats Adapter**: This adapter connects to the Nats Provider. Its primary responsibility is to receive workflow initiation messages and delegate them to available workers for execution.
-- **AutoGen Workflows**: These workflows, defined using the AutoGen framework, embody the core logic and behavior of your application. They leverage agents to perform various tasks and accomplish specific goals.
+    #### 1. FastAgency Client App
 
-### Interaction Flow
-1. The client initiates interaction with the Mesop UI or Custom UI in the FastAgency Client App.
-2. The Mesop UI or Custom UI relays requests, based on user actions, to the FastAPI Provider.
-3. The FastAPI Provider forwards these requests to the FastAPI Adapter in the FastAgency FastAPI App.
-4. The FastAPI Adapter processes the requests and sends a message to the Nats Provider to start the workflow.
-5. The Nats Adapter, connected to the Nats Provider, receives the workflow initiation message.
-6. The Nats Adapter distributes the task of executing the workflow to one of the available workers.
-7. The designated worker executes the AutoGen Workflow and sends the results back through the Nats Provider to the FastAPI Adapter.
-8. The FastAPI Adapter sends the results to the FastAPI Provider, which relays them to the Mesop UI or Custom UI for presentation to the client.
+    The FastAgency Client App serves as the frontend interface for the system. It includes:
 
-This architecture promotes a clear separation of concerns between the user interface, the API layer, and the workflow execution logic, enhancing modularity and maintainability. The FastAPI framework provides a user-friendly and efficient API, while the Nats Adapter, coupled with the Nats.io MQ message broker, ensures scalability and asynchronous communication.
+    - **Custom Client**: A custom web interface for users to interact with the workflows. It facilitates the communication with the user and the **FastAgency FastAPI App**.
 
-Now, it's time to see the FastAPI + Nats Adapter using FastAgency in action. Let's dive into an example and learn how to use it!
+    This custom client app handles all interactions with the **FastAgency FastAPI App** and presents the results back to the user.
+
+    #### 2. FastAgency FastAPI App
+
+    The FastAgency FastAPI App forms the backend of our system and consists of:
+
+    - **Nats Provider**: Responsible for connecting to the Nats Provider, receiving workflow initiation messages, and distributing them to the workers for execution.
+    - **FastAPI Adapter**: This component communicates with AutoGen, and implements routes and websocket for FastAPI.
+    - **FastAPI**: Provides the infrastructure for building and exposing AutoGen workflows via REST API.
+
+    #### 3. FastAgency Nats App
+    - **Nats Adapter**: This adapter connects to the Nats Provider. Its primary responsibility is to receive workflow initiation messages and delegate them to available workers for execution.
+    - **AutoGen Workflows**: These workflows, defined using the AutoGen framework, embody the core logic and behavior of your application. They leverage agents to perform various tasks and accomplish specific goals.
+
+    #### Building Custom Client Applications
+
+    For details on building a custom client that interacts with the FastAgency FastAPI backend, check out the guide [here](../fastapi/index.md#building-custom-client-applications). It covers the **routes, message types, and integration steps in detail**, helping you set up seamless communication with FastAgency’s FastAPI backend.
+
+Now, it's time to see the **FastAPI + Nats Adapter** using FastAgency in action. Let's dive into an example and learn how to use it!
 
 ## Installation
 
 Before getting started, make sure you have installed FastAgency by running the following command:
 
-```bash
-pip install "fastagency[autogen,mesop,fastapi,server,nats]"
-```
+=== "FastAPI + Nats Adapter with Mesop Client"
 
-This command installs FastAgency with support for both the Console and Mesop interfaces for AutoGen workflows, but with FastAPI serving input requests and independent workers communicating over Nats.io protocol running workflows.
+    ```bash
+    pip install "fastagency[autogen,mesop,fastapi,server,nats]"
+    ```
+
+    This command installs FastAgency with support for both the Console and Mesop interfaces for AutoGen workflows, but with FastAPI serving input requests and independent workers communicating over Nats.io protocol running workflows.
+
+=== "FastAPI + Nats Adapter with Custom Client"
+
+    ```bash
+    pip install "fastagency[autogen,fastapi,server,nats]"
+    ```
+
+    This command installs FastAgency, but with FastAPI serving input requests and independent workers communicating over Nats.io protocol running workflows.
 
 ## Example: Student and Teacher Learning Chat
 
-In this example, we'll create a simple learning chat where a student agent asks questions and a teacher agent responds, simulating a learning environment. We'll use **MesopUI** for the web interface and the **FastAPI + Nats** Adapter to expose the workflow as a REST API.
+=== "FastAPI + Nats Adapter with Mesop Client"
+
+    In this example, we'll create a simple learning chat where a student agent asks questions and a teacher agent responds, simulating a learning environment. We'll use **MesopUI** for the web interface and the **FastAPI + Nats** Adapter to expose the workflow as a REST API.
+
+    ### Step-by-Step Breakdown
+
+    As shown in the [architecture overview](#architecture-overview), this setup requires **three** components (applications). Let's begin with the first component, the [FastAgency NATS App](#3-fastagency-nats-app).
+
+=== "FastAPI + Nats Adapter with Custom Client"
 
-### Step-by-Step Breakdown
+    In this example, we'll create a simple learning chat where a student agent asks questions and a teacher agent responds, simulating a learning environment. We'll use **custom client** for the web interface and the **FastAPI + Nats** Adapter to expose the workflow as a REST API.
+
+    ### Step-by-Step Breakdown
+
+    As shown in the [architecture overview](#architecture-overview), this setup requires **three** components (applications). Let's begin with the first component, the [FastAgency NATS App](#3-fastagency-nats-app_1).
 
 #### 1. **Import Required Modules**
 
-To get started, import the required modules from the **FastAgency** and **AutoGen**. These imports provide the essential building blocks for creating agents, workflows, and integrating MesopUI.Additionally, import the [**`NatsAdapter`**](../../../api/fastagency/adapters/nats/NatsAdapter.md) class for workflow execution.
+To get started, import the required modules from the **FastAgency** and **AutoGen**. These imports provide the essential building blocks for creating agents, workflows, and integrating with the client. Additionally, import the [**`NatsAdapter`**](../../../api/fastagency/adapters/nats/NatsAdapter.md) class for workflow execution.
 
 ```python hl_lines="8"
 {!> docs_src/getting_started/nats_n_fastapi/main_1_nats.py [ln:1-9] !}
@@ -85,7 +143,7 @@ To get started, import the required modules from the **FastAgency** and **AutoGe
 Next, define the workflow that your application will use. This is where you specify how the agents interact and what they do. Here's a simple example of a workflow definition:
 
 ```python
-{! docs_src/getting_started/main_console.py [ln:9-53] !}
+{! docs_src/getting_started/nats_n_fastapi/main_1_nats.py [ln:11-52] !}
 ```
 
 #### 3. **Configure the Nats Adapter**
@@ -106,19 +164,46 @@ Create an NatsAdapter and then add it to a FastAPI application using the lifespa
 
 #### 5. **Adapter Chaining**
 
-Above, we created Nats.io provider that will start brokers waiting to consume initiate workflow messages from the message broker. Now, we create FastAPI service interacting with Nats.io provider:
+Above, we created Nats.io provider that will start brokers waiting to consume initiate workflow messages from the message broker.
 
-!!! note "main_2_fastapi.py"
-    ```python hl_lines="16-18 21-22"
-    {!> docs_src/getting_started/nats_n_fastapi/main_2_fastapi.py [ln:1-22] !}
-    ```
+=== "FastAPI + Nats Adapter with Mesop Client"
 
-Finally, we create Mesop app communicating with the FastAPI application:
+    Next, we set up a FastAPI service to interact with the NATS.io provider. This introduces the second component: the [**FastAgency FastAPI App**](#2-fastagency-fastapi-app).
 
-!!! note "main_3_mesop.py"
-    ```python hl_lines="7-9 11"
-    {!> docs_src/getting_started/nats_n_fastapi/main_3_mesop.py [ln:1-11] !}
-    ```
+    !!! note "main_2_fastapi.py"
+        ```python hl_lines="16-18 21-22"
+        {!> docs_src/getting_started/nats_n_fastapi/main_2_fastapi.py [ln:1-22] !}
+        ```
+
+    Finally, the third component is the [**FastAgency Client App**](#1-fastagency-client-app), which uses the **Mesop client** to communicate with both the user and the FastAPI provider.
+
+    !!! note "main_3_mesop.py"
+        ```python hl_lines="7-9 11"
+        {!> docs_src/getting_started/nats_n_fastapi/main_3_mesop.py [ln:1-11] !}
+        ```
+
+=== "FastAPI + Nats Adapter with Custom Client"
+
+    Next, we’ll set up a FastAPI service to interact with the NATS.io provider, introducing the second component: the [**FastAgency FastAPI App**](#2-fastagency-fastapi-app_1).
+
+
+    !!! note "main_fastapi_custom_client.py"
+        ```python hl_lines="17-19 22-23"
+        {!> docs_src/getting_started/nats_n_fastapi/main_2_fastapi_custom_client.py [ln:1-8,96-110] !}
+        ```
+
+    Finally, for simplicity, we will serve our custom HTML client as part of the same [**FastAgency FastAPI App**](#2-fastagency-fastapi-app_1) using FastAPI's [**HTMLResponse**](https://fastapi.tiangolo.com/advanced/custom-response/#html-response){target="_blank"}.
+
+    !!! note
+
+        - The below example uses a **simple HTML with JavaScript**, all in a single string and served directly from the FastAgency FastAPI app for **simplicity**.
+        - This approach is **not suitable for production** but ideal for demonstrating core concepts.
+        - In a real-world scenario, you'd use a separate frontend, built with frameworks like React or Vue.js, or other languages such as Java, Go, or Ruby, based on your project needs.
+
+    !!! note "main_fastapi_custom_client.py"
+        ```python
+        {!> docs_src/getting_started/nats_n_fastapi/main_2_fastapi_custom_client.py [ln:9-95,113-115] !}
+        ```
 
 
 #### 6. **Nats server setup**
@@ -135,81 +220,149 @@ In the above Nats configuration, we define a user called `fastagency`, and its p
 
 Please copy and paste the following code into the same folder, using the file names exactly as mentioned below.
 
-<details>
-    <summary>nats-server.conf</summary>
-    ```python
-    {!> docs_src/getting_started/nats_n_fastapi/nats-server.conf !}
-    ```
-</details>
+=== "FastAPI + Nats Adapter with Mesop Client"
+
+    <details>
+        <summary>nats-server.conf</summary>
+        ```python
+        {!> docs_src/getting_started/nats_n_fastapi/nats-server.conf !}
+        ```
+    </details>
+
+    <details>
+        <summary>main_1_nats.py</summary>
+        ```python
+        {!> docs_src/getting_started/nats_n_fastapi/main_1_nats.py !}
+        ```
+    </details>
+
+    <details>
+        <summary>main_2_fastapi.py</summary>
+        ```python
+        {!> docs_src/getting_started/nats_n_fastapi/main_2_fastapi.py !}
+        ```
+    </details>
+
+    <details>
+        <summary>main_3_mesop.py</summary>
+        ```python
+        {!> docs_src/getting_started/nats_n_fastapi/main_3_mesop.py !}
+        ```
+    </details>
+
+=== "FastAPI + Nats Adapter with Custom Client"
+
+    <details>
+        <summary>nats-server.conf</summary>
+        ```python
+        {!> docs_src/getting_started/nats_n_fastapi/nats-server.conf !}
+        ```
+    </details>
+
+    <details>
+        <summary>main_1_nats.py</summary>
+        ```python
+        {!> docs_src/getting_started/nats_n_fastapi/main_1_nats.py !}
+        ```
+    </details>
+
+    <details>
+        <summary>main_2_fastapi_custom_client.py</summary>
+        ```python
+        {!> docs_src/getting_started/nats_n_fastapi/main_2_fastapi_custom_client.py !}
+        ```
+    </details>
 
-<details>
-    <summary>main_1_nats.py</summary>
-    ```python
-    {!> docs_src/getting_started/nats_n_fastapi/main_1_nats.py !}
-    ```
-</details>
+### Run Application
 
-<details>
-    <summary>main_2_fastapi.py</summary>
-    ```python
-    {!> docs_src/getting_started/nats_n_fastapi/main_2_fastapi.py !}
-    ```
-</details>
+Once everything is set up, you can run your FastAgency application using the following commands.
 
-<details>
-    <summary>main_3_mesop.py</summary>
-    ```python
-    {!> docs_src/getting_started/nats_n_fastapi/main_3_mesop.py !}
-    ```
-</details>
+=== "FastAPI + Nats Adapter with Mesop Client"
 
-### Run Application
+    You need to run **Four** commands in **separate** terminal windows:
 
-Once everything is set up, you can run your FastAgency application using the following commands. You need to run **Four** commands in **separate** terminal windows:
+    - Start **Nats** Docker container:
+    !!! note "Terminal 1"
+        ```
+        docker run -d --name nats-fastagency --rm -p 4222:4222 -p 9222:9222 -p 8222:8222 -v $(pwd)/nats-server.conf:/etc/nats/nats-server.conf -e FASTAGENCY_NATS_PASSWORD='fastagency_nats_password' nats:latest -c /etc/nats/nats-server.conf
+        ```
 
-- Start **Nats** Docker container:
-!!! note "Terminal 1"
-    ```
-    docker run -d --name nats-fastagency --rm -p 4222:4222 -p 9222:9222 -p 8222:8222 -v $(pwd)/nats-server.conf:/etc/nats/nats-server.conf -e FASTAGENCY_NATS_PASSWORD='fastagency_nats_password' nats:latest -c /etc/nats/nats-server.conf
-    ```
+    - Start **FastAPI** application that provides a conversational workflow:
+    !!! note "Terminal 2"
+        ```
+        uvicorn main_1_nats:app --reload
+        ```
 
-- Start **FastAPI** application that provides a conversational workflow:
-!!! note "Terminal 2"
-    ```
-    uvicorn main_1_nats:app --reload
-    ```
+    - Start **FastAPI** application integrated with a **Nats** messaging system:
+    !!! note "Terminal 3"
+        ```
+        uvicorn main_2_fastapi:app --host 0.0.0.0 --port 8008 --reload
+        ```
 
-- Start **FastAPI** application integrated with a **Nats** messaging system:
-!!! note "Terminal 3"
-    ```
-    uvicorn main_2_fastapi:app --host 0.0.0.0 --port 8008 --reload
-    ```
+    - Start **Mesop** web interface using gunicorn:
+    !!! note "Terminal 4"
+        ```
+        gunicorn main_3_mesop:app -b 0.0.0.0:8888 --reload
+        ```
 
-- Start **Mesop** web interface using gunicorn:
-!!! note "Terminal 4"
-    ```
-    gunicorn main_3_mesop:app -b 0.0.0.0:8888 --reload
-    ```
+    !!! danger "Currently not working on **Windows**"
+        The above command is currently not working on **Windows**, because gunicorn is not supported. Please use the alternative method below to start the application:
+        ```
+        waitress-serve --listen=0.0.0.0:8888 main_3_mesop:app
+        ```
+
+=== "FastAPI + Nats Adapter with Custom Client"
+
+    You need to run **Three** commands in **separate** terminal windows:
+
+    - Start **Nats** Docker container:
+    !!! note "Terminal 1"
+        ```
+        docker run -d --name nats-fastagency --rm -p 4222:4222 -p 9222:9222 -p 8222:8222 -v $(pwd)/nats-server.conf:/etc/nats/nats-server.conf -e FASTAGENCY_NATS_PASSWORD='fastagency_nats_password' nats:latest -c /etc/nats/nats-server.conf
+        ```
+
+    - Start **FastAPI** application that provides a conversational workflow:
+    !!! note "Terminal 2"
+        ```
+        uvicorn main_1_nats:app --reload
+        ```
+
+    - Start **FastAPI** application integrated with a **Nats** messaging system:
+    !!! note "Terminal 3"
+        ```
+        uvicorn main_2_fastapi_custom_client:app --host 0.0.0.0 --port 8008 --reload
+        ```
 
-!!! danger "Currently not working on **Windows**"
-    The above command is currently not working on **Windows**, because gunicorn is not supported. Please use the alternative method below to start the application:
-    ```
-    waitress-serve --listen=0.0.0.0:8888 main_3_mesop:app
-    ```
 
 ### Output
 
 The outputs will vary based on the interface. Here is the output of the last terminal starting the UI:
 
-```console
-[2024-10-10 13:19:18 +0530] [23635] [INFO] Starting gunicorn 23.0.0
-[2024-10-10 13:19:18 +0530] [23635] [INFO] Listening at: http://127.0.0.1:8888 (23635)
-[2024-10-10 13:19:18 +0530] [23635] [INFO] Using worker: sync
-[2024-10-10 13:19:18 +0530] [23645] [INFO] Booting worker with pid: 23645
-```
+=== "FastAPI + Nats Adapter with Mesop Client"
+
+    ```console
+    [2024-10-10 13:19:18 +0530] [23635] [INFO] Starting gunicorn 23.0.0
+    [2024-10-10 13:19:18 +0530] [23635] [INFO] Listening at: http://127.0.0.1:8888 (23635)
+    [2024-10-10 13:19:18 +0530] [23635] [INFO] Using worker: sync
+    [2024-10-10 13:19:18 +0530] [23645] [INFO] Booting worker with pid: 23645
+    ```
+
+    ![Initial message](../../../getting-started/images/chat.png)
+
+
+=== "FastAPI + Nats Adapter with Custom Client"
+
+    ```console
+    INFO:     Will watch for changes in these directories: ['/tmp/custom_fastapi_demo']
+    INFO:     Uvicorn running on http://0.0.0.0:8008 (Press CTRL+C to quit)
+    INFO:     Started reloader process [73937] using StatReload
+    INFO:     Started server process [73940]
+    INFO:     Waiting for application startup.
+    INFO:     Application startup complete.
+    ```
+    ![Output Screenshot](../images/custom_chat_output.png)
 
-![Initial message](../../../getting-started/images/chat.png)
 
 The **FastAPI + Nats** Adapter in FastAgency provides a **highly scalable** and **flexible solution** for building distributed applications. By leveraging the power of [**FastAPI**](https://fastapi.tiangolo.com/){target="_blank"} for building REST APIs and the [**Nats.io MQ**](https://nats.io/){target="_blank"} for asynchronous communication, you can create robust and efficient workflows that can handle high user demand and complex production setups.
 
-Whether you're building custom client applications, scalable chat systems, or applications that require conversation auditing, the FastAPI + Nats Adapter has you covered.
+Whether you're building custom client applications, **scalable chat systems**, or applications that require **conversation auditing**, the **FastAPI + Nats Adapter** has you covered.
diff --git a/docs/docs/en/user-guide/adapters/images/custom_fastapi_nats.png b/docs/docs/en/user-guide/adapters/images/custom_fastapi_nats.png
new file mode 100644
index 00000000..c4f941dc
--- /dev/null
+++ b/docs/docs/en/user-guide/adapters/images/custom_fastapi_nats.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:960eb880b7d8bdf702e2a65af8b5e9cde43313b0acc54d94dacdafc154cfdfea
+size 85139
diff --git a/docs/docs/en/user-guide/adapters/images/mesop_fastapi.png b/docs/docs/en/user-guide/adapters/images/mesop_fastapi.png
index 37788819..22e2ac64 100644
--- a/docs/docs/en/user-guide/adapters/images/mesop_fastapi.png
+++ b/docs/docs/en/user-guide/adapters/images/mesop_fastapi.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:460349ba71161a9323af906719440d0693dba0994d3d6d3e207c936132c050e4
-size 79247
+oid sha256:7258266d558255dba1f7d4bec009c7a43ddc07042889551dd21cc3549803bf11
+size 73489
diff --git a/docs/docs/en/user-guide/adapters/images/mesop_fastapi_nats.png b/docs/docs/en/user-guide/adapters/images/mesop_fastapi_nats.png
index 5a162f09..b3ae57b0 100644
--- a/docs/docs/en/user-guide/adapters/images/mesop_fastapi_nats.png
+++ b/docs/docs/en/user-guide/adapters/images/mesop_fastapi_nats.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6c216ce0295d0713b7c45256933030fc5b272ed56f011eca3a1cb2113e8b0a75
-size 121975
+oid sha256:b25ebca6aac45df3d6b3bfea86f0f11070e304d1b80b71a7fed31cbaf06583a1
+size 114991
diff --git a/docs/docs/en/user-guide/adapters/nats/index.md b/docs/docs/en/user-guide/adapters/nats/index.md
index 09836013..2eea6126 100644
--- a/docs/docs/en/user-guide/adapters/nats/index.md
+++ b/docs/docs/en/user-guide/adapters/nats/index.md
@@ -4,15 +4,11 @@ The **Nats Adapter** in FastAgency enables seamless integration of your workflow
 
 ## Use Cases
 
-This section outlines the scenarios where it's particularly beneficial to use the **Nats** Adapter.
+When to Use the Nats Adapter:
 
-### When to Use the Nats Adapter
+- **High User Demand**: If you need to scale above what can be achieved with multiple-workers of the [**FastAPI** adapter](../fastapi/index.md), then you can use [**Nats.io MQ**](https://nats.io/){target="_blank"}-based message que and multiple workers consuming and producing messages. This kind of distributed, [message-queue architecture](https://en.wikipedia.org/wiki/Message_queue){target="_blank"} allows you to scale up not just across multiple workers, but also across multiple machines and even across multiple clusters.
 
-- **Default Client Application**: If you prefer using the **default Mesop client** provided by FastAgency without the need to build your own client application.
-
-- **High User Demand**: When your application requires **high scalability** to handle a large number of users or messages, and you are comfortable with a more complex production setup involving a message broker. For example, it's well-suited for building a **scalable chat application** for a larger company or external customers.
-
-- **Conversation Auditing**: If you need the ability to **audit conversations**, the Nats Adapter provides the necessary infrastructure to enable this feature.
+- **Observability**: If you need the ability to **audit workflow executions** both in realtime and posteriori, the Nats Adapter provides the necessary infrastructure to enable this feature.
 
 ## Architecture Overview
 
diff --git a/docs/docs/en/user-guide/runtimes/autogen/images/weather_chat.png b/docs/docs/en/user-guide/runtimes/autogen/images/weather_chat.png
new file mode 100644
index 00000000..1207afa2
--- /dev/null
+++ b/docs/docs/en/user-guide/runtimes/autogen/images/weather_chat.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6e8039fbd2dcd6b6c15274bc5517118e486db10e4b4819d82e3fd2e891725f31
+size 74317
diff --git a/docs/docs/en/user-guide/runtimes/autogen/index.md b/docs/docs/en/user-guide/runtimes/autogen/index.md
index b291451a..57e74d6f 100644
--- a/docs/docs/en/user-guide/runtimes/autogen/index.md
+++ b/docs/docs/en/user-guide/runtimes/autogen/index.md
@@ -1,76 +1,112 @@
 # AutoGen in FastAgency
 
-The **AutoGen** runtime is a key component of FastAgency, empowering developers to create intelligent, multi-agent systems powered by large language models (LLMs). AutoGen allows agents to communicate, collaborate, and perform complex tasks autonomously while easily integrating with external APIs for real-time data and functionality.
+The [**AutoGen**](../../../api/fastagency/runtimes/autogen/autogen/AutoGenWorkflows.md) runtime is a key component of FastAgency, empowering developers to create intelligent, [**multi-agent systems**](https://microsoft.github.io/autogen/0.2/docs/Use-Cases/agent_chat){target="_blank"} powered by [**large language models (LLMs)**](https://en.wikipedia.org/wiki/Large_language_model){target="_blank"}. It allows agents to communicate, collaborate, and perform complex tasks autonomously while easily integrating with external [**Rest APIs**](https://en.wikipedia.org/wiki/REST){target="_blank"} for real-time data and functionality.
 
-In this example, we will create a simple weather chatbot using **AutoGen** in FastAgency. The chatbot will enable a user to interact with a weather agent that fetches real-time weather information from an external API using OpenAPI specifications.
+In this example, we will create a simple weather [**chatbot**](https://en.wikipedia.org/wiki/Chatbot){target="_blank"} using [**AutoGen**](../../../api/fastagency/runtimes/autogen/autogen/AutoGenWorkflows.md) runtime in FastAgency. The chatbot will enable a user to interact with a weather agent that fetches real-time weather information from an external REST API using [**OpenAPI specification**](https://en.wikipedia.org/wiki/OpenAPI_Specification){target="_blank"}.
 
 ## Installation
 
-Before getting started, make sure you have installed FastAgency with support for the AutoGen runtime by running the following command:
+Before getting started, make sure you have installed FastAgency with support for the [**AutoGen**](../../../api/fastagency/runtimes/autogen/autogen/AutoGenWorkflows.md) runtime along with the [**mesop**](../../../api/fastagency/ui/mesop/MesopUI.md) and [**openapi**](../../../api/fastagency/api/openapi/OpenAPI.md) submodules by running the following command:
 
 ```bash
-pip install "fastagency[autogen,openapi]"
+pip install "fastagency[autogen,mesop,openapi]"
 ```
 
-This installation includes the AutoGen runtime, allowing you to build multi-agent workflows and integrate external APIs seamlessly.
+These components enable you to build  [**multi-agent workflows**](https://microsoft.github.io/autogen/0.2/docs/Use-Cases/agent_chat){target="_blank"} and seamlessly integrate with the external [**Rest APIs**](https://en.wikipedia.org/wiki/REST){target="_blank"}.
+
+## Prerequisites
+
+Before you begin this guide, ensure you have:
+
+- **OpenAI account and API Key**: This guide uses OpenAI's [**`gpt-4o-mini`**](https://openai.com/index/gpt-4o-mini-advancing-cost-efficient-intelligence/){target="_blank"} model, so you'll need access to it. Follow the steps in the section below to create your [**OpenAI**](https://openai.com){target="_blank"} account and obtain your API key.
+
+### Setting Up Your OpenAI Account and API Key
+
+**1. Create a OpenAI account:**
+
+- Go to <b><a href="https://platform.openai.com/signup" target="_blank">https://platform.openai.com/signup</a></b>.
+- Choose a **sign-up** option and follow the instructions to create your account.
+- If you already have an account, simply **log-in**.
+
+**2. Obtain your API Key:**
+
+- Go to <b><a href="https://platform.openai.com/account/api-keys" target="_blank">https://platform.openai.com/account/api-keys</a></b>.
+- Click **Create new secret key** button.
+- In the popup, provide a **Name** for the key, then click **Create secret key** button.
+- The key will be shown on the screen—click **Copy** button, and you're ready to go!
+
+#### Set Up Your API Keys in the Environment
+
+To securely use the API keys in your project, you should store it as an [**environment variable**](https://en.wikipedia.org/wiki/Environment_variable){target="_blank"}.
+
+Run the following command in the [**same terminal**](#running-the-application) where you will run the FastAgency application. This environment variable must be set for the application to function correctly; **skipping this step will cause the example application to crash**.
+
+=== "Linux/macOS"
+    ```bash
+    export OPENAI_API_KEY="your_open_api_key"
+    ```
+=== "Windows"
+    ```bash
+    set OPENAI_API_KEY="your_open_api_key"
+    ```
 
 ## Example: Integrating a Weather API with AutoGen
 
 ### Step-by-Step Breakdown
 
 #### 1. **Import Required Modules**
-The example starts by importing the necessary modules from **AutoGen** and **FastAgency**. These imports lay the foundation for building and running multi-agent workflows.
+The example starts by importing the necessary modules from [**AutoGen**](https://microsoft.github.io/autogen/){target="_blank"} and **FastAgency**. These imports lay the foundation for building and running [**multi-agent**](https://microsoft.github.io/autogen/0.2/docs/Use-Cases/agent_chat){target="_blank"} workflows.
 
 ```python
-{! docs_src/user_guide/runtimes/autogen/main.py [ln:1-10] !}
+{! docs_src/user_guide/runtimes/autogen/mesop/main.py [ln:1-10] !}
 ```
 
 #### 2. **Configure the Language Model (LLM)**
-Here, the large language model is configured to use the `gpt-4o` model, and the API key is retrieved from the environment. This setup ensures that both the user and weather agents can interact effectively.
+Here, the [**large language model**](https://en.wikipedia.org/wiki/Large_language_model){target="_blank"} is configured to use the Open AI's [**`gpt-4o-mini`**](https://openai.com/index/gpt-4o-mini-advancing-cost-efficient-intelligence/){target="_blank"} model, and the [**API key**](https://en.wikipedia.org/wiki/API_key){target="_blank"} is retrieved from the environment. This setup ensures that both the user and weather agents can interact effectively.
 
 ```python
-{! docs_src/user_guide/runtimes/autogen/main.py [ln:12-20] !}
+{! docs_src/user_guide/runtimes/autogen/mesop/main.py [ln:12-20] !}
 ```
 
 #### 3. **Set Up the Weather API**
-We define the OpenAPI specification URL for the weather service. This API will later be used by the weather agent to fetch real-time weather data.
+We define the [**OpenAPI specification**](https://en.wikipedia.org/wiki/OpenAPI_Specification){target="_blank"} URL for the weather service. This [**Rest APIs**](https://en.wikipedia.org/wiki/REST){target="_blank"} will later be used by the weather agent to fetch real-time weather data.
 
 ```python
-{! docs_src/user_guide/runtimes/autogen/main.py [ln:22-24] !}
+{! docs_src/user_guide/runtimes/autogen/mesop/main.py [ln:22-24] !}
 ```
 
 #### 4. **Define the Workflow and Agents**
 In this step, we define two agents and specify the initial message that will be displayed to users when the workflow starts.
 
-- **UserProxyAgent**: This agent simulates the user interacting with the system.
+- [**`UserProxyAgent`**](https://microsoft.github.io/autogen/0.2/docs/reference/agentchat/user_proxy_agent/#userproxyagent){target="_blank"}: This agent simulates the user interacting with the system.
 
-- **ConversableAgent**: This agent acts as the weather agent, responsible for fetching weather data from the API.
+- [**`ConversableAgent`**](https://microsoft.github.io/autogen/0.2/docs/reference/agentchat/conversable_agent/#conversableagent){target="_blank"}: This agent acts as the weather agent, responsible for fetching weather data from the API.
 
 The workflow is registered using **[AutoGenWorkflows](../../../api/fastagency/runtimes/autogen/AutoGenWorkflows/)**.
 
 ```python
-{! docs_src/user_guide/runtimes/autogen/main.py [ln:26-51] !}
+{! docs_src/user_guide/runtimes/autogen/mesop/main.py [ln:32-57] !}
 ```
 
 #### 5. **Register API Functions with the Agents**
-In this step, we register the weather API functions to ensure that the weather agent can call the correct functions, such as `get_daily_weather` and `get_daily_weather_weekly_get`, to retrieve the required weather data.
+In this step, we register the [**weather API**](https://weather.tools.fastagency.ai/docs){target="_blank"} functions to ensure that the weather agent can call the correct functions, such as `get_daily_weather` and `get_daily_weather_weekly_get`, to retrieve the required weather data.
 
 ```python
-{! docs_src/user_guide/runtimes/autogen/main.py [ln:52-65] !}
+{! docs_src/user_guide/runtimes/autogen/mesop/main.py [ln:58-73] !}
 ```
 
 #### 6. **Enable Agent Interaction and Chat**
-Here, the user agent initiates a chat with the weather agent, which queries the API and returns the weather information. The conversation is summarized using a method provided by the LLM.
+Here, the user agent initiates a chat with the weather agent, which queries the [**weather API**](https://weather.tools.fastagency.ai/docs){target="_blank"} and returns the weather information. The conversation is summarized using a method provided by the [**LLM**](https://en.wikipedia.org/wiki/Large_language_model){target="_blank"}.
 
 ```python
-{! docs_src/user_guide/runtimes/autogen/main.py [ln:67-74] !}
+{! docs_src/user_guide/runtimes/autogen/mesop/main.py [ln:73-82] !}
 ```
 
 #### 7. **Create and Run the Application**
-Finally, we create the FastAgency application and launch it using the console interface.
+Finally, we create the FastAgency application and launch it using the [**`mesop`**](../../../api/fastagency/ui/mesop/MesopUI.md) interface.
 
 ```python
-{! docs_src/user_guide/runtimes/autogen/main.py [ln:77] !}
+{! docs_src/user_guide/runtimes/autogen/mesop/main.py [ln:84] !}
 ```
 
 ### Complete Application Code
@@ -78,55 +114,59 @@ Finally, we create the FastAgency application and launch it using the console in
 <details>
 <summary>main.py</summary>
 ```python
-{! docs_src/user_guide/runtimes/autogen/main.py!}
+{! docs_src/user_guide/runtimes/autogen/mesop/main.py!}
 ```
 </details>
 
 
 ### Running the Application
 
-```bash
-fastagency run
-```
+There are two options of running a Mesop application:
+
+1. Using [**`fastagency`**](../../cli/index.md) command:
+
+    !!! note "Terminal (using [**`fastagency`**](../../cli/index.md))"
+        ```
+        fastagency run
+        ```
+
+    !!! danger "Currently not working on **MacOS**"
+        The above command is currently not working on **MacOS**, please use the alternative way of starting the application from below ([#362](https://github.com/airtai/fastagency/issues/362){target="_blank"}).
 
-Ensure you have set your OpenAI API key in the environment and that the weather API URL is accessible. The command will launch a console interface where users can input their requests and interact with the weather agent.
+2. Using [**Gunicorn**](https://gunicorn.org/){target="_blank"} WSGI HTTP server:
+
+    The preferred way to run the [**Mesop**](https://google.github.io/mesop/){target="_blank"} application is using a Python WSGI HTTP server like [**Gunicorn**](https://gunicorn.org/){target="_blank"}. First, you need to install it using package manager such as `pip` and then run it as follows:
+
+    !!! note "Terminal (using [**Gunicorn**](https://gunicorn.org/){target="_blank"})"
+        ```
+        pip install gunicorn
+        gunicorn main:app
+        ```
+
+    !!! danger "Currently not working on **Windows**"
+        The above command is currently not working on **Windows**, because gunicorn is not supported. Please use the alternative method below to start the application:
+        ```
+        pip install waitress
+        waitress-serve --listen=0.0.0.0:8000 main:app
+        ```
+
+Ensure you have set your [**OpenAI API key**](https://platform.openai.com/api-keys){target="_blank"} in the environment and that the [**weather API**](https://weather.tools.fastagency.ai/docs){target="_blank"} URL is accessible. The command will launch a [**`mesopUI`**](../../../api/fastagency/ui/mesop/MesopUI.md) interface where users can input their requests and interact with the weather agent.
 
 ### Output
 
-Once you run it, FastAgency automatically detects the appropriate app to execute and runs it. The application will then prompt you with: "I can help you with the weather. What would you like to know?".
+Once you run the command above, FastAgency will start a [**Mesop**](https://google.github.io/mesop/){target="_blank"} application. Below is the output from the terminal along with a partial screenshot of the Mesop application:
 
 ```console
-╭─ Python module file ─╮
-│                      │
-│  🐍 main.py          │
-│                      │
-╰──────────────────────╯
-
-
-╭─ Importable FastAgency app ─╮
-│                             │
-│  from main import app       │
-│                             │
-╰─────────────────────────────╯
-
-╭─ FastAgency -> user [workflow_started] ──────────────────────────────────────╮
-│                                                                              │
-│ {                                                                            │
-│   "name": "simple_weather",                                                  │
-│   "description": "Weather chat",                                             │
-│                                                                              │
-│ "params": {}                                                                 │
-│ }                                                                            │
-╰──────────────────────────────────────────────────────────────────────────────╯
-
-╭─ Workflow -> User [text_input] ──────────────────────────────────────────────╮
-│                                                                              │
-│ I can help you with the weather. What would you like to know?:               │
-╰──────────────────────────────────────────────────────────────────────────────╯
+[2024-10-10 13:19:18 +0530] [23635] [INFO] Starting gunicorn 23.0.0
+[2024-10-10 13:19:18 +0530] [23635] [INFO] Listening at: http://127.0.0.1:8000 (23635)
+[2024-10-10 13:19:18 +0530] [23635] [INFO] Using worker: sync
+[2024-10-10 13:19:18 +0530] [23645] [INFO] Booting worker with pid: 23645
 ```
 
+![Initial message](./images/weather_chat.png)
+
 ---
 
-This example demonstrates the power of the **AutoGen** runtime within FastAgency, showing how easy it is to integrate LLM-powered agents with real-time API services. By leveraging FastAgency, developers can quickly create interactive, scalable applications that interact with external data sources in real-time.
+This example demonstrates the power of the [**AutoGen**](../../../api/fastagency/runtimes/autogen/autogen/AutoGenWorkflows.md) runtime within FastAgency, showing how easy it is to integrate [**LLM**](https://en.wikipedia.org/wiki/Large_language_model){target="_blank"}-powered agents with real-time [**Rest API**](https://en.wikipedia.org/wiki/REST){target="_blank"} services. By leveraging FastAgency, developers can quickly create interactive, scalable applications that interact with external data sources in real-time.
 
-For more detailed documentation, visit the [AutoGen Reference](../../../api/fastagency/runtimes/autogen/AutoGenWorkflows/).
+For more detailed documentation, visit the [**AutoGen Reference**](../../../api/fastagency/runtimes/autogen/AutoGenWorkflows/).
diff --git a/docs/docs/en/user-guide/runtimes/autogen/using_non_openai_models.md b/docs/docs/en/user-guide/runtimes/autogen/using_non_openai_models.md
index 46975179..7f492be2 100644
--- a/docs/docs/en/user-guide/runtimes/autogen/using_non_openai_models.md
+++ b/docs/docs/en/user-guide/runtimes/autogen/using_non_openai_models.md
@@ -1,84 +1,85 @@
 # Using Non-OpenAI Models with FastAgency
 
-FastAgency makes it simple to work with **non-OpenAI models** through AutoGen's runtime. You can do this in a couple of ways:
+FastAgency makes it simple to work with **non-OpenAI models** through its [**AutoGen**](../../../api/fastagency/runtimes/autogen/autogen/AutoGenWorkflows.md) runtime. You can do this in a couple of ways:
 
-- via [proxy servers that provide an OpenAI-compatible API](https://microsoft.github.io/autogen/0.2/docs/topics/non-openai-models/about-using-nonopenai-models/#openai-compatible-api-proxy-server){target="_blank"}
-- by [using a custom model client class](https://microsoft.github.io/autogen/0.2/docs/topics/non-openai-models/about-using-nonopenai-models/#custom-model-client-class){target="_blank"}, which lets you define and load your own models.
+- Using a [**proxy server that provides an OpenAI-compatible API**](https://microsoft.github.io/autogen/0.2/docs/topics/non-openai-models/about-using-nonopenai-models/#openai-compatible-api-proxy-server){target="_blank"} or
+- By [**using a custom model client class**](https://microsoft.github.io/autogen/0.2/docs/topics/non-openai-models/about-using-nonopenai-models/#custom-model-client-class){target="_blank"}, which lets you define and load your own models.
 
 This flexibility allows you to **access a variety of models**, assign **tailored models to agents**, and **optimise inference costs**, among other advantages.
 
-To show how simple it is to use **non-OpenAI models**, we'll **rewrite** the [Weatherman chatbot](./index.md#example-integrating-a-weather-api-with-autogen) example. With just a **few changes**, we'll switch to the [Together AI](https://www.together.ai){target="_blank"} Cloud platform, utilizing their **Meta-Llama-3.1-70B-Instruct-Turbo** model. For a comprehensive list of models available through Together AI, please refer to their official [documentation](https://docs.together.ai/docs/chat-models){target="_blank"}.
+To show how simple it is to use **non-OpenAI models**, we'll **rewrite** the [**Weatherman chatbot**](./index.md#example-integrating-a-weather-api-with-autogen) example. With just a **few changes**, we'll switch to the [**Together AI**](https://www.together.ai){target="_blank"} Cloud platform, utilizing their **Meta-Llama-3.1-70B-Instruct-Turbo** model. For a comprehensive list of models available through Together AI, please refer to their official [**documentation**](https://docs.together.ai/docs/chat-models){target="_blank"}.
 
 Let’s dive in!
 
 ## Installation
 
-Before getting started, make sure you have installed FastAgency with **[autogen](../../../api/fastagency/runtimes/autogen/autogen/AutoGenWorkflows.md) and [openapi](../../../api/fastagency/api/openapi/OpenAPI.md) submodules** by running the following command:
+Before you get started, ensure that you have FastAgency installed. Run the following command:
 
 ```bash
-pip install "fastagency[autogen,openapi]"
+pip install "fastagency[autogen,mesop,openapi]"
 ```
 
-This installation includes the AutoGen runtime, allowing you to build multi-agent workflows and integrate external APIs seamlessly.
+This command installs the FastAgency library along with the  [**AutoGen**](../../../api/fastagency/runtimes/autogen/autogen/AutoGenWorkflows.md) runtime and the [**mesop**](../../../api/fastagency/ui/mesop/MesopUI.md) and [**openapi**](../../../api/fastagency/api/openapi/OpenAPI.md) submodules. These components enable you to build  [**multi-agent workflows**](https://microsoft.github.io/autogen/0.2/docs/Use-Cases/agent_chat){target="_blank"} and seamlessly integrate with the external [**Rest APIs**](https://en.wikipedia.org/wiki/REST){target="_blank"}.
 
 ## Prerequisites
 
 Before you begin this guide, ensure you have:
 
-- **Together AI account and API Key**: To create a [Together AI](https://www.together.ai){target="_blank"} account and obtain your API key, follow the steps in the section below.
+- **Together AI account and API Key**: This guide uses [**Together AI's**](https://www.together.ai){target="_blank"} **Meta-Llama-3.1-70B-Instruct-Turbo** model, so you'll need access to it. Follow the steps in the section below to create your Together AI account and obtain your API key.
+
 
 ### Setting Up Your Together AI Account and API Key
 
 **1. Create a Together AI account:**
 
-- Go to <a href="https://api.together.ai" target="_blank">https://api.together.ai</a>.
-- Choose a sign-in option and follow the instructions to create your account.
-- If you already have an account, simply log in.
+- Go to <b><a href="https://api.together.ai" target="_blank">https://api.together.ai</a></b>.
+- Choose a **sign-in** option and follow the instructions to create your account.
+- If you already have an account, simply **log-in**.
 
 **2. Obtain your API Key:**
 
 - Once you complete the account creation process the API key will be displayed on the screen which you can copy.
 - Or you can do the following to view your API key:
-    - Tap on the person icon at the top right corner, and click [Settings](https://api.together.ai/settings/profile){target="_blank"}
-    - On the left side bar, navigate to [API Keys](https://api.together.ai/settings/api-keys){target="_blank"}
+    - Tap on the person icon at the top right corner, and click [**Settings**](https://api.together.ai/settings/profile){target="_blank"}
+    - On the left side bar, navigate to [**API Keys**](https://api.together.ai/settings/api-keys){target="_blank"}
     - **Copy your API key**, and you're ready to go!
 
 #### Set Up Your API Keys in the Environment
 
-To securely use the API keys in your project, you should store it in an environment variables.
+To securely use the API keys in your project, you should store it as an [**environment variable**](https://en.wikipedia.org/wiki/Environment_variable){target="_blank"}.
 
-You can set the together API key in your terminal as an environment variable:
+Run the following command in the [**same terminal**](#running-the-application) where you will run the FastAgency application. This environment variable must be set for the application to function correctly; **skipping this step will cause the example application to crash**.
 
 === "Linux/macOS"
     ```bash
-    export TOGETHER_API_KEY="your_together_api_key"  # pragma: allowlist secret
+    export TOGETHER_API_KEY="your_together_api_key"
     ```
 === "Windows"
     ```bash
-    set TOGETHER_API_KEY="your_together_api_key"  # pragma: allowlist secret
+    set TOGETHER_API_KEY="your_together_api_key"
     ```
 
 ## Example: Integrating a Weather API with AutoGen
 
 ### Code Walkthrough
 
-As we rewrite the existing [Weatherman chatbox](./index.md#example-integrating-a-weather-api-with-autogen) to use **non-OpenAI models**, most of the code remains unchanged. The only modifications to the original code are:
+As we rewrite the existing [**Weatherman chatbox**](./index.md#example-integrating-a-weather-api-with-autogen) to use **non-OpenAI models**, most of the code remains unchanged. The only modifications to the original code are:
 
 - **Configure the Language Model (LLM)**
 - **Update the System Message**
 
-Since the modifications are minor, **I will focus only on these differences in this guide**. For a **detailed explanation** of the original code, please refer to the original [guide](./index.md#example-integrating-a-weather-api-with-autogen).
+Since the modifications are minor, **I will focus only on these differences in this guide**. For a **detailed explanation** of the original code, please refer to the original [**guide**](./index.md#autogen-in-fastagency).
 
 #### 1. Configure the Language Model (LLM)
 
-First, update the LLM configuration to use **non-OpenAI models**. For our example, we'll use **meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo**, but you can choose any model from [Together AI](https://www.together.ai){target="_blank"} Cloud. For a complete list, refer to their official [documentation](https://docs.together.ai/docs/chat-models){target="_blank"}.
+First, update the [**LLM**](https://en.wikipedia.org/wiki/Large_language_model){target="_blank"} configuration to use **non-OpenAI models**. For our example, we'll use **meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo**, but you can choose any model from [**Together AI**](https://www.together.ai){target="_blank"} Cloud. For a complete list, refer to their official [**documentation**](https://docs.together.ai/docs/chat-models){target="_blank"}.
 
 
 Next, add two parameters: `api_type` and `hide_tools`.
 
 - `hide_tools`
 
-    The [hide_tools](https://microsoft.github.io/autogen/0.2/docs/topics/non-openai-models/local-ollama#reducing-repetitive-tool-calls){target="_blank"} in AutoGen controls when tools are visible during LLM conversations. It addresses a common issue where LLMs might **repeatedly recommend tool calls**, even after they've been executed, potentially creating an **endless loop** of tool invocations.
+    The [**`hide_tools`**](https://microsoft.github.io/autogen/0.2/docs/topics/non-openai-models/local-ollama#reducing-repetitive-tool-calls){target="_blank"} in [**AutoGen**](https://microsoft.github.io/autogen/){target="_blank"} controls when tools are visible during [**LLM**](https://en.wikipedia.org/wiki/Large_language_model){target="_blank"} conversations. It addresses a common issue where LLMs might **repeatedly recommend tool calls**, even after they've been executed, potentially creating an **endless loop** of tool invocations.
 
     This parameter offers three options to control tool visibility:
 
@@ -93,7 +94,7 @@ Next, add two parameters: `api_type` and `hide_tools`.
     Set the `api_type` to `together` to instruct FastAgency to use Together AI Cloud for model inference.
 
 ```python
-{! docs_src/user_guide/runtimes/autogen/using_non_openai_models.py [ln:12-22] !}
+{! docs_src/user_guide/runtimes/autogen/mesop/using_non_openai_models.py [ln:12-22] !}
 ```
 
 #### 2. Update the System Message
@@ -101,7 +102,7 @@ Next, add two parameters: `api_type` and `hide_tools`.
 The system message has been adjusted to work optimally with the **meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo** model. You may need to experiment with the system prompt if you are using a different model.
 
 ```python
-{! docs_src/user_guide/runtimes/autogen/using_non_openai_models.py [ln:27-32] !}
+{! docs_src/user_guide/runtimes/autogen/mesop/using_non_openai_models.py [ln:27-32] !}
 ```
 
 ### Complete Application Code
@@ -109,131 +110,52 @@ The system message has been adjusted to work optimally with the **meta-llama/Met
 <details>
 <summary>main.py</summary>
 ```python
-{! docs_src/user_guide/runtimes/autogen/using_non_openai_models.py !}
+{! docs_src/user_guide/runtimes/autogen/mesop/using_non_openai_models.py !}
 ```
 </details>
 
 ### Running the Application
 
-Once the workflow is set up, you can run the application using the **FastAgency CLI**. Navigate to the directory where the script is located and run the following command:
+There are two options of running a Mesop application:
 
-```bash
-fastagency run
-```
+1. Using [**`fastagency`**](../../cli/index.md) command line:
+
+    !!! note "Terminal (using [**`fastagency`**](../../cli/index.md))"
+        ```
+        fastagency run
+        ```
+
+    !!! danger "Currently not working on **MacOS**"
+        The above command is currently not working on **MacOS**, please use the alternative way of starting the application from below ([#362](https://github.com/airtai/fastagency/issues/362){target="_blank"}).
+
+2. Using [**Gunicorn**](https://gunicorn.org/){target="_blank"} WSGI HTTP server:
+
+    The preferred way to run the [**Mesop**](https://google.github.io/mesop/){target="_blank"} application is using a Python WSGI HTTP server like [**Gunicorn**](https://gunicorn.org/){target="_blank"}. First, you need to install it using package manager such as `pip` and then run it as follows:
+
+    !!! note "Terminal (using [**Gunicorn**](https://gunicorn.org/){target="_blank"})"
+        ```
+        pip install gunicorn
+        gunicorn main:app
+        ```
+
+    !!! danger "Currently not working on **Windows**"
+        The above command is currently not working on **Windows**, because gunicorn is not supported. Please use the alternative method below to start the application:
+        ```
+        pip install waitress
+        waitress-serve --listen=0.0.0.0:8000 main:app
+        ```
 
 ### Output
 
-The output will vary based on the city and the current weather conditions:
+Once you run the command above, FastAgency will start a [**Mesop**](https://google.github.io/mesop/){target="_blank"} application. Below is the output from the terminal along with a partial screenshot of the Mesop application:
 
 ```console
-╭─ Python module file ─╮
-│                      │
-│  🐍 main.py          │
-│                      │
-╰──────────────────────╯
-
-
-╭─ Importable FastAgency app ─╮
-│                             │
-│  from main import app       │
-│                             │
-╰─────────────────────────────╯
-
-╭─ FastAgency -> user [workflow_started] ──────────────────────────────────────╮
-│                                                                              │
-│ {                                                                            │
-│   "name": "simple_weather",                                                  │
-│   "description": "Weather chat",                                             │
-│                                                                              │
-│ "params": {}                                                                 │
-│ }                                                                            │
-╰──────────────────────────────────────────────────────────────────────────────╯
-
-    ╭─ Workflow -> User [text_input] ──────────────────────────────────────────────╮
-    │                                                                              │
-    │ I can help you with the weather. What would you like to know?:               │
-    ╰──────────────────────────────────────────────────────────────────────────────╯
-What's the weather in Zagreb
-╭─ User_Agent -> Weather_Agent [text_message] ─────────────────────────────────╮
-│                                                                              │
-│ What's the weather in Zagreb                                                 │
-╰──────────────────────────────────────────────────────────────────────────────╯
-
-╭─ Weather_Agent -> User_Agent [text_message] ─────────────────────────────────╮
-│                                                                              │
-│ Please wait while I fetch the weather data for Zagreb...                     │
-╰──────────────────────────────────────────────────────────────────────────────╯
-
-╭─ User_Agent -> Weather_Agent [suggested_function_call] ──────────────────────╮
-│                                                                              │
-│ {                                                                            │
-│   "function_name": "get_daily_weather_daily_get",                            │
-│   "call_id":                                                                 │
-│ "call_fwdnhh2bptuauqqniiwha4g7",                                             │
-│   "arguments": {                                                             │
-│     "city": "Zagreb"                                                         │
-│                                                                              │
-│   }                                                                          │
-│ }                                                                            │
-╰──────────────────────────────────────────────────────────────────────────────╯
-
-╭─ Weather_Agent -> User_Agent [function_call_execution] ──────────────────────╮
-│                                                                              │
-│ {                                                                            │
-│   "function_name": "get_daily_weather_daily_get",                            │
-│   "call_id":                                                                 │
-│ "call_fwdnhh2bptuauqqniiwha4g7",                                             │
-│   "retval": "{\"city\": \"Zagreb\",                                          │
-│ \"temperature\": 17, \"daily_forecasts\": [{\"forecast_date\":               │
-│ \"2024-10-14\", \"temperature\": 14, \"hourly_forecasts\": null},            │
-│ {\"forecast_date\": \"2024-10-15\", \"temperature\": 15,                     │
-│ \"hourly_forecasts\": null}, {\"forecast_date\": \"2024-10-16\",             │
-│ \"temperature\": 15, \"hourly_forecasts\": null}]}\n"                        │
-│ }                                                                            │
-╰──────────────────────────────────────────────────────────────────────────────╯
-
-╭─ User_Agent -> Weather_Agent [text_message] ─────────────────────────────────╮
-│                                                                              │
-│ The current weather in Zagreb is 17 degrees Celsius. The forecast for        │
-│ the next few days is as follows:                                             │
-│                                                                              │
-│ - October 14, 2024: 14 degrees                                               │
-│ Celsius                                                                      │
-│ - October 15, 2024: 15 degrees Celsius                                       │
-│ - October 16, 2024: 15                                                       │
-│ degrees Celsius                                                              │
-╰──────────────────────────────────────────────────────────────────────────────╯
-
-╭─ Weather_Agent -> User_Agent [text_message] ─────────────────────────────────╮
-│                                                                              │
-│ The current weather in Zagreb is 17 degrees Celsius. The forecast for        │
-│ the next few days is as follows:                                             │
-│                                                                              │
-│ - October 14, 2024: 14 degrees                                               │
-│ Celsius                                                                      │
-│ - October 15, 2024: 15 degrees Celsius                                       │
-│ - October 16, 2024: 15                                                       │
-│ degrees Celsius                                                              │
-╰──────────────────────────────────────────────────────────────────────────────╯
-
-╭─ AutoGenWorkflows -> user [workflow_completed] ──────────────────────────────╮
-│                                                                              │
-│ {                                                                            │
-│   "result": {                                                                │
-│     "content": "The current weather in Zagreb is 17                          │
-│ degrees Celsius, with forecasted temperatures of 14 degrees Celsius on       │
-│  October 14, 15 degrees Celsius on October 15, and 15 degrees Celsius        │
-│ on October 16.",                                                             │
-│     "refusal": null,                                                         │
-│     "role": "assistant",                                                     │
-│                                                                              │
-│ "function_call": null,                                                       │
-│     "tool_calls": null                                                       │
-│   }                                                                          │
-│ }                                                                            │
-╰──────────────────────────────────────────────────────────────────────────────╯
-
-2024-10-14 19:37:11,923 [INFO] Workflow 'simple_weather' completed with result: {'content': 'The current weather in Zagreb is 17 degrees Celsius, with forecasted temperatures of 14 degrees Celsius on October 14, 15 degrees Celsius on October 15, and 15 degrees Celsius on October 16.', 'refusal': None, 'role': 'assistant', 'function_call': None, 'tool_calls': None}
+[2024-10-10 13:19:18 +0530] [23635] [INFO] Starting gunicorn 23.0.0
+[2024-10-10 13:19:18 +0530] [23635] [INFO] Listening at: http://127.0.0.1:8000 (23635)
+[2024-10-10 13:19:18 +0530] [23635] [INFO] Using worker: sync
+[2024-10-10 13:19:18 +0530] [23645] [INFO] Booting worker with pid: 23645
 ```
 
-This example demonstrates the power of AutoGen's runtime in FastAgency, highlighting how easily you can use **non-OpenAI models** with just a few changes in the code. With FastAgency, developers can **quickly build interactive**, **scalable applications** that work with live data sources.
+![Initial message](./images/weather_chat.png)
+
+This example demonstrates the power of [**AutoGen**](../../../api/fastagency/runtimes/autogen/autogen/AutoGenWorkflows.md) runtime in FastAgency, highlighting how easily you can use **non-OpenAI models** with just a few changes in the code. With FastAgency, developers can **quickly build interactive**, **scalable applications** that work with live data sources.
diff --git a/docs/docs/en/user-guide/ui/mesop/basics.md b/docs/docs/en/user-guide/ui/mesop/basics.md
index c35b610f..47dbdf42 100644
--- a/docs/docs/en/user-guide/ui/mesop/basics.md
+++ b/docs/docs/en/user-guide/ui/mesop/basics.md
@@ -135,9 +135,9 @@ There are two options of running a Mesop application:
     !!! danger "Currently not working on **MacOS**"
         The above command is currently not working on **MacOS**, please use the alternative way of starting the application from below ([#362](https://github.com/airtai/fastagency/issues/362){target="_blank"}).
 
-2. Using [Gunicorn](https://gunicorn.org/){target="_blank"} WSGI HTTP server:
+2. Using [**Gunicorn**](https://gunicorn.org/){target="_blank"} WSGI HTTP server:
 
-    The preferred way to run the Mesop application is using a Python WSGI HTTP server like [Gunicorn](https://gunicorn.org/){target="_blank"}. First, you need to install it using package manager such as `pip` and then run it as follows:
+    The preferred way to run the [**Mesop**](https://google.github.io/mesop/){target="_blank"} application is using a Python WSGI HTTP server like [**Gunicorn**](https://gunicorn.org/){target="_blank"}. First, you need to install it using package manager such as `pip` and then run it as follows:
 
     !!! note "Terminal (using [Gunicorn](https://gunicorn.org/){target="_blank"})"
         ```
diff --git a/docs/docs_src/getting_started/fastapi/main_custom_fastapi_client.py b/docs/docs_src/getting_started/fastapi/main_fastapi_custom_client.py
similarity index 98%
rename from docs/docs_src/getting_started/fastapi/main_custom_fastapi_client.py
rename to docs/docs_src/getting_started/fastapi/main_fastapi_custom_client.py
index 0bd3d544..368acd37 100644
--- a/docs/docs_src/getting_started/fastapi/main_custom_fastapi_client.py
+++ b/docs/docs_src/getting_started/fastapi/main_fastapi_custom_client.py
@@ -149,4 +149,4 @@ async def get() -> HTMLResponse:
 
 
 # start the provider with the following command
-# uvicorn main_custom_fastapi_client:app --host 0.0.0.0 --port 8008 --reload
+# uvicorn main_fastapi_custom_client:app --host 0.0.0.0 --port 8008 --reload
diff --git a/docs/docs_src/getting_started/nats_n_fastapi/main_2_fastapi_custom_client.py b/docs/docs_src/getting_started/nats_n_fastapi/main_2_fastapi_custom_client.py
new file mode 100644
index 00000000..09acfa38
--- /dev/null
+++ b/docs/docs_src/getting_started/nats_n_fastapi/main_2_fastapi_custom_client.py
@@ -0,0 +1,119 @@
+from os import environ
+
+from fastapi import FastAPI
+from fastapi.responses import HTMLResponse
+
+from fastagency.adapters.fastapi import FastAPIAdapter
+from fastagency.adapters.nats import NatsAdapter
+
+html = """
+<!DOCTYPE html>
+<html>
+   <head>
+      <title>FastAgency Chat App</title>
+   </head>
+   <body>
+      <h1>FastAgency Chat App</h1>
+      <div id="workflows"></div>
+      <ul id="messages"></ul>
+      <script>
+         const API_URL = 'http://0.0.0.0:8008/fastagency';
+         const WS_URL = 'ws://0.0.0.0:8008/fastagency/ws'; // nosemgrep
+         let socket;
+
+         async function fetchWorkflows() {
+             const response = await fetch(`${API_URL}/discovery`);
+             const workflows = await response.json();
+             const container = document.getElementById('workflows');
+             workflows.forEach(workflow => {
+                 const button = document.createElement('button');
+                 button.textContent = workflow.description;
+                 button.onclick = () => startWorkflow(workflow.name);
+                 container.appendChild(button);
+             });
+         }
+
+         async function startWorkflow(name) {
+             const payload = {
+                 workflow_name: name,
+                 workflow_uuid: generateUUID(),
+                 user_id: null, // Set to null for single-user applications; otherwise, provide the appropriate user ID
+                 params: {}
+             };
+             const response = await fetch(`${API_URL}/initiate_workflow`, {
+                 method: 'POST',
+                 headers: { 'Content-Type': 'application/json' },
+                 body: JSON.stringify(payload)
+             });
+             const workflowJson = await response.json();
+             connectWebSocket(workflowJson);
+         }
+
+         function connectWebSocket(workflowJson) {
+             socket = new WebSocket(WS_URL);
+             socket.onopen = () => {
+                 const initMessage = {
+                     name: workflowJson.name,
+                     workflow_uuid: workflowJson.workflow_uuid,
+                     user_id: workflowJson.user_id,
+                     params: {}
+                 };
+                 socket.send(JSON.stringify(initMessage));
+             };
+             socket.onmessage = (event) => handleMessage(JSON.parse(event.data));
+         }
+
+         function handleMessage(message) {
+             const messagesList = document.getElementById('messages');
+             const li = document.createElement('li');
+             if (message.type === 'text_input') {
+                 const response = prompt(message.content.prompt);
+                 socket.send(response);
+                 li.textContent = `${message.sender} -> ${message.recipient}: ${message.content.prompt}`;
+             } else {
+                 li.textContent = `${message.sender} -> ${message.recipient}: ${message.content?.body || message?.type || JSON.stringify(message)}`;
+             }
+             messagesList.appendChild(li);
+         }
+
+         fetchWorkflows();
+
+         // Helper function for generating UUID
+         function generateUUID() {
+            return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+                if (c === 'x') {
+                return (Math.random() * 16 | 0).toString(16);
+                } else {
+                return (Math.random() * 16 | 0 & 0x3 | 0x8).toString(16);
+                }
+            });
+         }
+      </script>
+   </body>
+</html>
+"""
+
+nats_url = environ.get("NATS_URL", "nats://localhost:4222")
+nats_user: str = "fastagency"
+nats_password: str = environ.get("FASTAGENCY_NATS_PASSWORD", "fastagency_nats_password")  # type: ignore[assignment]
+
+provider = NatsAdapter.create_provider(
+    nats_url=nats_url, user=nats_user, password=nats_password
+)
+
+adapter = FastAPIAdapter(
+    provider=provider,
+)
+
+# app = FastAPI(lifespan=provider.lifespan)
+app = FastAPI()
+app.include_router(adapter.router)
+
+
+@app.get("/")
+async def get() -> HTMLResponse:
+    return HTMLResponse(html)
+
+
+# start the provider with the following command
+# uvicorn main_2_fastapi_custom_client:app --host 0.0.0.0 --port 8008 --reload
diff --git a/docs/docs_src/user_guide/runtimes/autogen/mesop/__init__.py b/docs/docs_src/user_guide/runtimes/autogen/mesop/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/docs/docs_src/user_guide/runtimes/autogen/main.py b/docs/docs_src/user_guide/runtimes/autogen/mesop/main.py
similarity index 79%
rename from docs/docs_src/user_guide/runtimes/autogen/main.py
rename to docs/docs_src/user_guide/runtimes/autogen/mesop/main.py
index d38ca577..f32efcf3 100644
--- a/docs/docs_src/user_guide/runtimes/autogen/main.py
+++ b/docs/docs_src/user_guide/runtimes/autogen/mesop/main.py
@@ -7,7 +7,7 @@ from autogen.agentchat import ConversableAgent
 from fastagency import UI, FastAgency
 from fastagency.api.openapi import OpenAPI
 from fastagency.runtimes.autogen import AutoGenWorkflows
-from fastagency.ui.console import ConsoleUI
+from fastagency.ui.mesop import MesopUI
 
 llm_config = {
     "config_list": [
@@ -23,6 +23,12 @@ openapi_url = "https://weather.tools.fastagency.ai/openapi.json"
 
 weather_api = OpenAPI.create(openapi_url=openapi_url)
 
+weather_agent_system_message = """You are a weather agent. When asked
+for weather, always call the function to get real-time data immediately.
+Do not respond until the data is retrieved. Provide the actual weather
+concisely based only on the real-time data from the function. Do not
+use any pre-existing knowledge or memory."""
+
 wf = AutoGenWorkflows()
 
 
@@ -41,10 +47,11 @@ def weather_workflow(
         system_message="You are a user agent",
         llm_config=llm_config,
         human_input_mode="NEVER",
+        code_execution_config=False
     )
     weather_agent = ConversableAgent(
         name="Weather_Agent",
-        system_message="You are a weather agent",
+        system_message=weather_agent_system_message,
         llm_config=llm_config,
         human_input_mode="NEVER",
     )
@@ -74,4 +81,4 @@ def weather_workflow(
     return chat_result.summary  # type: ignore[no-any-return]
 
 
-app = FastAgency(provider=wf, ui=ConsoleUI())
+app = FastAgency(provider=wf, ui=MesopUI())
diff --git a/docs/docs_src/user_guide/runtimes/autogen/using_non_openai_models.py b/docs/docs_src/user_guide/runtimes/autogen/mesop/using_non_openai_models.py
similarity index 83%
rename from docs/docs_src/user_guide/runtimes/autogen/using_non_openai_models.py
rename to docs/docs_src/user_guide/runtimes/autogen/mesop/using_non_openai_models.py
index a3eb7c86..f60f6574 100644
--- a/docs/docs_src/user_guide/runtimes/autogen/using_non_openai_models.py
+++ b/docs/docs_src/user_guide/runtimes/autogen/mesop/using_non_openai_models.py
@@ -7,7 +7,7 @@ from autogen.agentchat import ConversableAgent
 from fastagency import UI, FastAgency
 from fastagency.api.openapi import OpenAPI
 from fastagency.runtimes.autogen import AutoGenWorkflows
-from fastagency.ui.console import ConsoleUI
+from fastagency.ui.mesop import MesopUI
 
 llm_config = {
     "config_list": [
@@ -24,12 +24,11 @@ llm_config = {
 openapi_url = "https://weather.tools.fastagency.ai/openapi.json"
 weather_api = OpenAPI.create(openapi_url=openapi_url)
 
-weather_agent_system_message = """You are a real-time weather agent. When asked
+weather_agent_system_message = """You are a weather agent. When asked
 about the weather for a specific city, NEVER provide any information from
-memory. ALWAYS respond with: "Please wait while I fetch the weather data for
-[city name]..." and immediately call the provided function to retrieve
-real-time data for that city. Be concise in your response. Only handle one
-city request at a time."""
+memory. ALWAYS respond with: "Please hold on while I retrieve the real-time
+weather data for [city name]." and immediately call the provided function to
+retrieve real-time data for that city. Be concise in your response."""
 
 wf = AutoGenWorkflows()
 
@@ -48,6 +47,7 @@ def weather_workflow(
         system_message="You are a user agent",
         llm_config=llm_config,
         human_input_mode="NEVER",
+        code_execution_config=False
     )
     weather_agent = ConversableAgent(
         name="Weather_Agent",
@@ -81,4 +81,4 @@ def weather_workflow(
     return chat_result.summary  # type: ignore[no-any-return]
 
 
-app = FastAgency(provider=wf, ui=ConsoleUI())
+app = FastAgency(provider=wf, ui=MesopUI())


Test patch:
diff --git a/tests/docs_src/test_import.py b/tests/docs_src/test_import.py
index 71512d63..47e8e75c 100644
--- a/tests/docs_src/test_import.py
+++ b/tests/docs_src/test_import.py
@@ -39,6 +39,7 @@ def test_submodules(module: str) -> None:
                 module.startswith("docs_src.user_guide.ui.mesop")
                 or module == "docs_src.tutorial.giphy"
                 or module == "docs_src.tutorial.whatsapp"
+                or module == "docs_src.user_guide.runtimes.autogen.mesop"
             ):
                 pass
             elif ("mesop" in module) or ("giphy" in module) or ("whatsapp" in module):
diff --git a/tests/docs_src/user_guide/runtimes/autogen/test_main.py b/tests/docs_src/user_guide/runtimes/autogen/test_main.py
deleted file mode 100644
index c21be03f..00000000
--- a/tests/docs_src/user_guide/runtimes/autogen/test_main.py
+++ /dev/null
@@ -1,25 +0,0 @@
-import pytest
-from typer.testing import CliRunner
-
-from fastagency.cli import app
-
-from .....conftest import InputMock
-from ....helpers import skip_internal_server_error
-
-runner = CliRunner()
-
-INPUT_MESSAGE = "What's the weather in Zagreb?"
-
-
-@pytest.mark.openai
-@skip_internal_server_error
-def test_main(monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.setattr("builtins.input", InputMock([INPUT_MESSAGE]))
-
-    result = runner.invoke(
-        app,
-        ["run", "docs/docs_src/user_guide/runtimes/autogen/main.py", "--single-run"],
-    )
-    assert result.exit_code == 0
-    assert INPUT_MESSAGE in result.stdout
-    assert "AutoGenWorkflows -> User [workflow_completed]" in result.stdout
diff --git a/tests/docs_src/user_guide/runtimes/autogen/test_using_non_openai_models.py b/tests/docs_src/user_guide/runtimes/autogen/test_using_non_openai_models.py
deleted file mode 100644
index 81884515..00000000
--- a/tests/docs_src/user_guide/runtimes/autogen/test_using_non_openai_models.py
+++ /dev/null
@@ -1,29 +0,0 @@
-import pytest
-from typer.testing import CliRunner
-
-from fastagency.cli import app
-
-from .....conftest import InputMock
-from ....helpers import skip_internal_server_error
-
-runner = CliRunner()
-
-INPUT_MESSAGE = "Get me daily forecast for Zagreb city"
-
-
-@pytest.mark.openai
-@skip_internal_server_error
-def test_cli_together_ai(monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.setattr("builtins.input", InputMock([INPUT_MESSAGE]))
-
-    result = runner.invoke(
-        app,
-        [
-            "run",
-            "docs/docs_src/user_guide/runtimes/autogen/using_non_openai_models.py",
-            "--single-run",
-        ],
-    )
-    assert result.exit_code == 0
-    assert INPUT_MESSAGE in result.stdout
-    assert "get_daily_weather" in result.stdout