Skip to content

A programming framework for agentic AI

Sample for integrating Core API with chainlit (#6422)

DavidYu00bacfa98aa61d
diff --git a/python/samples/core_chainlit/.gitignore b/python/samples/core_chainlit/.gitignore
new file mode 100644
index 000000000..ab341606b
--- /dev/null
+++ b/python/samples/core_chainlit/.gitignore
@@ -0,0 +1,3 @@
+model_config.yaml
+.chainlit
+chainlit.md
\ No newline at end of file
diff --git a/python/samples/core_chainlit/README.md b/python/samples/core_chainlit/README.md
new file mode 100644
index 000000000..527be9fff
--- /dev/null
+++ b/python/samples/core_chainlit/README.md
@@ -0,0 +1,64 @@
+# Core ChainLit Integration Sample
+
+In this sample, we will demonstrate how to build simple chat interface that
+interacts with a [Core](https://microsoft.github.io/autogen/stable/user-guide/core-user-guide/index.html)
+agent or a team, using [Chainlit](https://github.com/Chainlit/chainlit),
+and support streaming messages.
+
+## Overview
+
+The `core_chainlit` sample is designed to illustrate a simple use case of ChainLit integrated with a single-threaded agent runtime. It includes the following components:
+
+- **Single Agent**: A single agent that operates within the ChainLit environment.
+- **Group Chat**: A group chat setup featuring two agents:
+ - **Assistant Agent**: This agent responds to user inputs.
+ - **Critic Agent**: This agent reflects on and critiques the responses from the Assistant Agent.
+- **Closure Agent**: Utilizes a closure agent to aggregate output messages into an output queue.
+- **Token Streaming**: Demonstrates how to stream tokens to the user interface.
+- **Session Management**: Manages the runtime and output queue within the ChainLit user session.
+
+## Requirements
+
+To run this sample, you will need:
+- Python 3.8 or higher
+- Installation of necessary Python packages as listed in `requirements.txt`
+
+## Installation
+
+To run this sample, you will need to install the following packages:
+
+```shell
+pip install -U chainlit autogen-core autogen-ext[openai] pyyaml
+```
+
+To use other model providers, you will need to install a different extra
+for the `autogen-ext` package.
+See the [Models documentation](https://microsoft.github.io/autogen/stable/user-guide/agentchat-user-guide/tutorial/models.html) for more information.
+
+## Model Configuration
+
+Create a configuration file named `model_config.yaml` to configure the model
+you want to use. Use `model_config_template.yaml` as a template.
+
+
+## Running the Agent Sample
+
+The first sample demonstrate how to interact with a single AssistantAgent
+from the chat interface.
+Note: cd to the sample directory.
+
+```shell
+chainlit run app_agent.py
+```
+
+## Running the Team Sample
+
+The second sample demonstrate how to interact with a team of agents from the
+chat interface.
+
+```shell
+chainlit run app_team.py -h
+```
+
+There are two agents in the team: one is instructed to be generally helpful
+and the other one is instructed to be a critic and provide feedback.
\ No newline at end of file
diff --git a/python/samples/core_chainlit/SimpleAssistantAgent.py b/python/samples/core_chainlit/SimpleAssistantAgent.py
new file mode 100644
index 000000000..32a7ab3cc
--- /dev/null
+++ b/python/samples/core_chainlit/SimpleAssistantAgent.py
@@ -0,0 +1,222 @@
+from typing import AsyncGenerator, List, Optional
+import asyncio
+import json
+from dataclasses import dataclass
+
+from autogen_core import (
+ CancellationToken,
+ DefaultTopicId,
+ FunctionCall,
+ message_handler,
+ MessageContext,
+ RoutedAgent,
+ TopicId
+)
+from autogen_core.models import (
+ AssistantMessage,
+ ChatCompletionClient,
+ CreateResult,
+ LLMMessage,
+ SystemMessage,
+ UserMessage,
+ FunctionExecutionResult,
+ FunctionExecutionResultMessage
+)
+
+from autogen_core.tools import Tool
+from pydantic import BaseModel
+
+@dataclass
+class Message:
+ content: str
+
+class StreamResult(BaseModel):
+ content: str | CreateResult | AssistantMessage
+ source: str
+
+class GroupChatMessage(BaseModel):
+ body: UserMessage
+
+class RequestToSpeak(BaseModel):
+ pass
+
+TASK_RESULTS_TOPIC_TYPE = "task-results"
+task_results_topic_id = TopicId(type=TASK_RESULTS_TOPIC_TYPE, source="default")
+
+class SimpleAssistantAgent(RoutedAgent):
+ def __init__(
+ self,
+ name: str,
+ system_message: str,
+ #context: MessageContext,
+ model_client: ChatCompletionClient,
+ tool_schema: List[Tool] = [],
+ model_client_stream: bool = False,
+ reflect_on_tool_use: bool | None = None,
+ group_chat_topic_type: str = "Default",
+ ) -> None:
+ super().__init__(name)
+ self._system_message = SystemMessage(content=system_message)
+ self._model_client = model_client
+ self._tools = tool_schema
+ #self._model_context = context
+ self._model_client_stream = model_client_stream
+ self._reflect_on_tool_use = reflect_on_tool_use
+ self._group_chat_topic_type = group_chat_topic_type
+ self._chat_history: List[LLMMessage] = []
+
+ async def _call_model_client(
+ self, cancellation_token: CancellationToken
+ ) -> AsyncGenerator[str | CreateResult, None]:
+ # Call the LLM model to process the message
+ model_result = None
+ async for chunk in self._model_client.create_stream(
+ messages=[self._system_message] + self._chat_history,
+ tools=self._tools,
+ cancellation_token=cancellation_token,
+ ):
+ if isinstance(chunk, CreateResult):
+ model_result = chunk
+ elif isinstance(chunk, str):
+ yield chunk
+ else:
+ raise RuntimeError(f"Invalid chunk type: {type(chunk)}")
+
+ if model_result is None: # No final result in model client respons
+ raise RuntimeError("No final model result in streaming mode.")
+
+ yield model_result
+ return
+
+ async def _execute_tool_call(
+ self, call: FunctionCall, cancellation_token: CancellationToken
+ ) -> FunctionExecutionResult:
+ # Find the tool by name.
+ tool = next((tool for tool in self._tools if tool.name == call.name), None)
+ assert tool is not None
+
+ # Run the tool and capture the result.
+ try:
+ arguments = json.loads(call.arguments)
+ result = await tool.run_json(arguments, cancellation_token)
+ return FunctionExecutionResult(
+ call_id=call.id, content=tool.return_value_as_string(result), is_error=False, name=tool.name
+ )
+ except Exception as e:
+ return FunctionExecutionResult(call_id=call.id, content=str(e), is_error=True, name=tool.name)
+
+ @message_handler
+ async def handle_user_message(self, message: UserMessage, ctx: MessageContext) -> Message:
+
+ # Append the message to chat history.
+ self._chat_history.append(
+ message
+ )
+
+ # Add message to model context.
+ # await self._model_context.add_message(UserMessage(content=message.content, source="User"))
+ model_result: Optional[CreateResult] = None
+
+ async for chunk in self._call_model_client(
+ cancellation_token=ctx.cancellation_token,
+ ):
+ if isinstance(chunk, CreateResult):
+ model_result = chunk
+ elif isinstance(chunk, str):
+ # foward the stream tokent to the Queue
+ await self.runtime.publish_message(StreamResult(content=chunk, source=self.id.type), topic_id=task_results_topic_id)
+ else:
+ raise RuntimeError(f"Invalid chunk type: {type(chunk)}")
+
+ if model_result is None: # No final result in model client respons
+ raise RuntimeError("No final model result in streaming mode.")
+
+ # Add the first model create result to the session.
+ self._chat_history.append(AssistantMessage(content=model_result.content, source=self.id.type))
+
+ if isinstance(model_result.content, str): # No tools, return the result
+ await self.runtime.publish_message(StreamResult(content=model_result, source=self.id.type), topic_id=task_results_topic_id)
+ return (Message(content= model_result.content))
+
+ # Execute the tool calls.
+ assert isinstance(model_result.content, list) and all(
+ isinstance(call, FunctionCall) for call in model_result.content
+ )
+ results = await asyncio.gather(
+ *[self._execute_tool_call(call, ctx.cancellation_token) for call in model_result.content]
+ )
+
+ # Add the function execution results to the session.
+ self._chat_history.append(FunctionExecutionResultMessage(content=results))
+
+ #if (not self._reflect_on_tool_use):
+ # return Message(content=model_result.content)
+
+ # Run the chat completion client again to reflect on the history and function execution results.
+ #model_result = None
+ model_result2: Optional[CreateResult] = None
+ async for chunk in self._call_model_client(
+ cancellation_token=ctx.cancellation_token,
+ ):
+ if isinstance(chunk, CreateResult):
+ model_result2 = chunk
+ elif isinstance(chunk, str):
+ # foward the stream tokent to the Queue
+ await self.runtime.publish_message(StreamResult(content=chunk, source=self.id.type), topic_id=task_results_topic_id)
+ else:
+ raise RuntimeError(f"Invalid chunk type: {type(chunk)}")
+
+ if model_result2 is None:
+ raise RuntimeError("No final model result in streaming mode.")
+ assert model_result2.content is not None
+ assert isinstance(model_result2.content, str)
+
+ await self.runtime.publish_message(StreamResult(content=model_result2, source=self.id.type), topic_id=task_results_topic_id)
+
+ return Message(content=model_result2.content)
+
+ # Message handler for Group chat message. It just add the message to the agent message history.
+ # The message will be processed when the agent receives the RequestToSpeak.
+ @message_handler
+ async def handle_message(self, message: GroupChatMessage, ctx: MessageContext) -> None:
+ self._chat_history.extend(
+ [
+ UserMessage(content=f"Transferred to {message.body.source}", source="system"),
+ message.body,
+ ]
+ )
+
+ # Message handler for request to speaker message.
+ @message_handler
+ async def handle_request_to_speak(self, message: RequestToSpeak, ctx: MessageContext) -> None:
+ #print(f"### {self.id.type}: ")
+ self._chat_history.append(
+ UserMessage(content=f"Transferred to {self.id.type}, adopt the persona immediately.", source="system")
+ )
+
+ # Run the chat completion client again to reflect on the history and function execution results.
+ model_result: Optional[CreateResult] = None
+ async for chunk in self._call_model_client(
+ cancellation_token=ctx.cancellation_token,
+ ):
+ if isinstance(chunk, CreateResult):
+ model_result = chunk
+ await self.runtime.publish_message(StreamResult(content=model_result, source=self.id.type), topic_id=task_results_topic_id)
+ elif isinstance(chunk, str):
+ # foward the stream tokent to the Queue
+ await self.runtime.publish_message(StreamResult(content=chunk, source=self.id.type), topic_id=task_results_topic_id)
+ else:
+ raise RuntimeError(f"Invalid chunk type: {type(chunk)}")
+
+ if model_result is None:
+ raise RuntimeError("No final model result in streaming mode.")
+
+ assert isinstance(model_result.content, str)
+ assert model_result.content is not None
+
+ self._chat_history.append(AssistantMessage(content=model_result.content, source=self.id.type))
+ #print(model_result.content, flush=True)
+ await self.publish_message(
+ GroupChatMessage(body=UserMessage(content=model_result.content, source=self.id.type)),
+ topic_id=DefaultTopicId(type=self._group_chat_topic_type),
+ )
\ No newline at end of file
diff --git a/python/samples/core_chainlit/app_agent.py b/python/samples/core_chainlit/app_agent.py
new file mode 100644
index 000000000..0ce158745
--- /dev/null
+++ b/python/samples/core_chainlit/app_agent.py
@@ -0,0 +1,112 @@
+from typing import List, cast
+import chainlit as cl
+import yaml
+
+import asyncio
+#from dataclasses import dataclass
+
+from autogen_core import (
+ AgentId,
+ MessageContext,
+ SingleThreadedAgentRuntime,
+ ClosureAgent,
+ ClosureContext,
+ TopicId,
+ TypeSubscription
+)
+from autogen_core.models import (
+ ChatCompletionClient,
+ CreateResult,
+ UserMessage,
+)
+
+from autogen_core.tools import FunctionTool, Tool
+#from autogen_ext.models.openai import OpenAIChatCompletionClient
+#from autogen_core.model_context import BufferedChatCompletionContext
+from SimpleAssistantAgent import SimpleAssistantAgent, StreamResult
+
+TASK_RESULTS_TOPIC_TYPE = "task-results"
+task_results_topic_id = TopicId(type=TASK_RESULTS_TOPIC_TYPE, source="default")
+CLOSURE_AGENT_TYPE = "collect_result_agent"
+
[email protected]_starters # type: ignore
+async def set_starts() -> List[cl.Starter]:
+ return [
+ cl.Starter(
+ label="Greetings",
+ message="Hello! What can you help me with today?",
+ ),
+ cl.Starter(
+ label="Weather",
+ message="Find the weather in New York City.",
+ ),
+ ]
+
+# Function called when closure agent receives message. It put the messages to the output queue
+async def output_result(_agent: ClosureContext, message: StreamResult, ctx: MessageContext) -> None:
+ queue = cast(asyncio.Queue[StreamResult], cl.user_session.get("queue_stream")) # type: ignore
+ await queue.put(message)
+
[email protected](type="tool") # type: ignore
+async def get_weather(city: str) -> str:
+ return f"The weather in {city} is 73 degrees and Sunny."
+
[email protected]_chat_start # type: ignore
+async def start_chat() -> None:
+
+ # Load model configuration and create the model client.
+ with open("model_config.yaml", "r") as f:
+ model_config = yaml.safe_load(f)
+ model_client = ChatCompletionClient.load_component(model_config)
+ #context = BufferedChatCompletionContext(buffer_size=10)
+
+ # Create a runtime and save to chainlit session
+ runtime = SingleThreadedAgentRuntime()
+ cl.user_session.set("run_time", runtime) # type: ignore
+
+ # Create tools
+ tools: List[Tool] = [FunctionTool(get_weather, description="Get weather tool.")]
+
+ # Create a queue for output stream data and save to chainlit session
+ queue_stream = asyncio.Queue[StreamResult]()
+ cl.user_session.set("queue_stream", queue_stream) # type: ignore
+
+ # Create the assistant agent with the get_weather tool.
+ await SimpleAssistantAgent.register(runtime, "weather_agent", lambda: SimpleAssistantAgent(
+ name="weather_agent",
+ tool_schema=tools,
+ model_client=model_client,
+ system_message="You are a helpful assistant",
+ #context=context,
+ model_client_stream=True, # Enable model client streaming.
+ reflect_on_tool_use=True, # Reflect on tool use.
+ ))
+
+ # Register the Closure Agent to process streaming chunks from agents by exeucting the output_result
+ # function, whihc sends the stream response to the output queue
+ await ClosureAgent.register_closure(
+ runtime, CLOSURE_AGENT_TYPE, output_result, subscriptions=lambda:[TypeSubscription(topic_type=TASK_RESULTS_TOPIC_TYPE, agent_type=CLOSURE_AGENT_TYPE)]
+ )
+
+ runtime.start() # Start processing messages in the background.
+
[email protected]_message # type: ignore
+async def chat(message: cl.Message) -> None:
+ # Construct the response message for the user message received.
+ ui_resp = cl.Message("")
+
+ # Get the runtime and queue from the session
+ runtime = cast(SingleThreadedAgentRuntime, cl.user_session.get("run_time")) # type: ignore
+ queue = cast(asyncio.Queue[StreamResult], cl.user_session.get("queue_stream")) # type: ignore
+
+ task1 = asyncio.create_task( runtime.send_message(UserMessage(content=message.content, source="User"), AgentId("weather_agent", "default")))
+
+ # Consume items from the response queue until the stream ends or an error occurs
+ while True:
+ stream_msg = await queue.get()
+ if (isinstance(stream_msg.content, str)):
+ await ui_resp.stream_token(stream_msg.content)
+ elif (isinstance(stream_msg.content, CreateResult)):
+ await ui_resp.send()
+ break
+ await task1
\ No newline at end of file
diff --git a/python/samples/core_chainlit/app_team.py b/python/samples/core_chainlit/app_team.py
new file mode 100644
index 000000000..85b5be757
--- /dev/null
+++ b/python/samples/core_chainlit/app_team.py
@@ -0,0 +1,201 @@
+from typing import List, cast
+import chainlit as cl
+import yaml
+import uuid
+import string
+import asyncio
+
+from autogen_core import (
+ ClosureAgent,
+ ClosureContext,
+ DefaultTopicId,
+ MessageContext,
+ message_handler,
+ RoutedAgent,
+ SingleThreadedAgentRuntime,
+ TopicId,
+ TypeSubscription,
+)
+from autogen_core.models import (
+ AssistantMessage,
+ ChatCompletionClient,
+ CreateResult,
+ #LLMMessage,
+ UserMessage,
+)
+
+from SimpleAssistantAgent import SimpleAssistantAgent, StreamResult, GroupChatMessage, RequestToSpeak
+
+assistant_topic_type = "assistant"
+critic_topic_type = "critic"
+group_chat_topic_type = "group_chat"
+
+TASK_RESULTS_TOPIC_TYPE = "task-results"
+task_results_topic_id = TopicId(type=TASK_RESULTS_TOPIC_TYPE, source="default")
+CLOSURE_AGENT_TYPE = "collect_result_agent"
+
+class GroupChatManager(RoutedAgent):
+ def __init__(
+ self,
+ participant_topic_types: List[str],
+ model_client: ChatCompletionClient,
+ ) -> None:
+ super().__init__("Group chat manager")
+ self._participant_topic_types = participant_topic_types
+ self._model_client = model_client
+ self._chat_history: List[UserMessage] = []
+ self._previous_participant_idx = -1
+
+ @message_handler
+ async def handle_message(self, message: GroupChatMessage, ctx: MessageContext) -> None:
+ assert isinstance(message.body, UserMessage)
+ self._chat_history.append(message.body)
+ # If the message is an approval message from the user, stop the chat.
+ if message.body.source == "User":
+ assert isinstance(message.body.content, str)
+ if message.body.content.lower().strip(string.punctuation).endswith("approve"): # type: ignore
+ await self.runtime.publish_message(StreamResult(content="stop", source=self.id.type), topic_id=task_results_topic_id)
+ return
+ if message.body.source == "Critic":
+ #if ("approve" in message.body.content.lower().strip(string.punctuation)):
+ if message.body.content.lower().strip(string.punctuation).endswith("approve"): # type: ignore
+ stop_msg = AssistantMessage(content="Task Finished", source=self.id.type)
+ await self.runtime.publish_message(StreamResult(content=stop_msg, source=self.id.type), topic_id=task_results_topic_id)
+ return
+
+ # Simple round robin algorithm to call next client to speak
+ selected_topic_type: str
+ idx = self._previous_participant_idx +1
+ if (idx == len(self._participant_topic_types)):
+ idx = 0
+ selected_topic_type = self._participant_topic_types[idx]
+ self._previous_participant_idx = idx
+
+ # Send the RequestToSpeak message to next agent
+ await self.publish_message(RequestToSpeak(), DefaultTopicId(type=selected_topic_type))
+
+# Function called when closure agent receives message. It put the messages to the output queue
+async def output_result(_agent: ClosureContext, message: StreamResult, ctx: MessageContext) -> None:
+ queue = cast(asyncio.Queue[StreamResult], cl.user_session.get("queue_stream")) # type: ignore
+ await queue.put(message)
+
[email protected]_chat_start # type: ignore
+async def start_chat() -> None:
+
+ # Load model configuration and create the model client.
+ with open("model_config.yaml", "r") as f:
+ model_config = yaml.safe_load(f)
+ model_client = ChatCompletionClient.load_component(model_config)
+
+ runtime = SingleThreadedAgentRuntime()
+ cl.user_session.set("run_time", runtime) # type: ignore
+ queue = asyncio.Queue[StreamResult]()
+ cl.user_session.set("queue_stream", queue) # type: ignore
+
+ # Create the assistant agent.
+ assistant_agent_type = await SimpleAssistantAgent.register(runtime, "Assistant", lambda: SimpleAssistantAgent(
+ name="Assistant",
+ group_chat_topic_type=group_chat_topic_type,
+ model_client=model_client,
+ system_message="You are a helpful assistant",
+ model_client_stream=True, # Enable model client streaming.
+ ))
+
+ # Assistant agent listen to assistant topic and group chat topic
+ await runtime.add_subscription(TypeSubscription(topic_type=assistant_topic_type, agent_type=assistant_agent_type.type))
+ await runtime.add_subscription(TypeSubscription(topic_type=group_chat_topic_type, agent_type=assistant_agent_type.type))
+
+ # Create the critic agent.
+ critic_agent_type = await SimpleAssistantAgent.register(runtime, "Critic", lambda: SimpleAssistantAgent(
+ name="Critic",
+ group_chat_topic_type=group_chat_topic_type,
+ model_client=model_client,
+ system_message="You are a critic. Provide constructive feedback. Respond with 'APPROVE' if your feedback has been addressed.",
+ model_client_stream=True, # Enable model client streaming.
+ ))
+
+ # Critic agent listen to critic topic and group chat topic
+ await runtime.add_subscription(TypeSubscription(topic_type=critic_topic_type, agent_type=critic_agent_type.type))
+ await runtime.add_subscription(TypeSubscription(topic_type=group_chat_topic_type, agent_type=critic_agent_type.type))
+
+ # Chain the assistant and critic agents using group_chat_manager.
+ group_chat_manager_type = await GroupChatManager.register(
+ runtime,
+ "group_chat_manager",
+ lambda: GroupChatManager(
+ participant_topic_types=[assistant_topic_type, critic_topic_type],
+ model_client=model_client,
+ ),
+ )
+ await runtime.add_subscription(
+ TypeSubscription(topic_type=group_chat_topic_type, agent_type=group_chat_manager_type.type)
+ )
+
+ # Register the Closure Agent, it will place streamed response into the output queue by calling output_result function
+ await ClosureAgent.register_closure(
+ runtime, CLOSURE_AGENT_TYPE, output_result, subscriptions=lambda:[TypeSubscription(topic_type=TASK_RESULTS_TOPIC_TYPE, agent_type=CLOSURE_AGENT_TYPE)]
+ )
+ runtime.start() # Start processing messages in the background.
+
+ cl.user_session.set("prompt_history", "") # type: ignore
+
+
[email protected]_starters # type: ignore
+async def set_starts() -> List[cl.Starter]:
+ return [
+ cl.Starter(
+ label="Poem Writing",
+ message="Write a poem about the ocean.",
+ ),
+ cl.Starter(
+ label="Story Writing",
+ message="Write a story about a detective solving a mystery.",
+ ),
+ cl.Starter(
+ label="Write Code",
+ message="Write a function that merge two list of numbers into single sorted list.",
+ ),
+ ]
+
+async def pass_msg_to_ui() -> None:
+ queue = cast(asyncio.Queue[StreamResult], cl.user_session.get("queue_stream")) # type: ignore
+ ui_resp = cl.Message("")
+ first_message = True
+ while True:
+ stream_msg = await queue.get()
+ if (isinstance(stream_msg.content, str)):
+ if (first_message):
+ ui_resp = cl.Message(content= stream_msg.source + ": ")
+ first_message = False
+ await ui_resp.stream_token(stream_msg.content)
+ elif (isinstance(stream_msg.content, CreateResult)):
+ await ui_resp.send()
+ ui_resp = cl.Message("")
+ first_message = True
+ else:
+ # This is a stop meesage
+ if (stream_msg.content.content == "stop"):
+ break
+ break
+
+
[email protected]_message # type: ignore
+async def chat(message: cl.Message) -> None:
+ # Construct the response message.
+
+ # Get the runtime and queue from the session
+ runtime = cast(SingleThreadedAgentRuntime, cl.user_session.get("run_time")) # type: ignore
+ queue = cast(asyncio.Queue[StreamResult], cl.user_session.get("queue_stream")) # type: ignore
+ output_msg = cl.Message(content="")
+ cl.user_session.set("output_msg", output_msg) # type: ignore
+
+ # Publish the user message to the Group Chat
+ session_id = str(uuid.uuid4())
+ await runtime.publish_message( GroupChatMessage( body=UserMessage(
+ content=message.content,
+ source="User",
+ )
+ ),
+ TopicId(type=group_chat_topic_type, source=session_id),)
+ task1 = asyncio.create_task( pass_msg_to_ui())
+ await task1
\ No newline at end of file
diff --git a/python/samples/core_chainlit/model_config_template.yaml b/python/samples/core_chainlit/model_config_template.yaml
new file mode 100644
index 000000000..c43f0a5bd
--- /dev/null
+++ b/python/samples/core_chainlit/model_config_template.yaml
@@ -0,0 +1,26 @@
+# Use Open AI with key
+provider: autogen_ext.models.openai.OpenAIChatCompletionClient
+config:
+ model: gpt-4o
+ api_key: REPLACE_WITH_YOUR_API_KEY
+# Use Azure Open AI with key
+# provider: autogen_ext.models.openai.AzureOpenAIChatCompletionClient
+# config:
+# model: gpt-4o
+# azure_endpoint: https://{your-custom-endpoint}.openai.azure.com/
+# azure_deployment: {your-azure-deployment}
+# api_version: {your-api-version}
+# api_key: REPLACE_WITH_YOUR_API_KEY
+# Use Azure OpenAI with AD token provider.
+# provider: autogen_ext.models.openai.AzureOpenAIChatCompletionClient
+# config:
+# model: gpt-4o
+# azure_endpoint: https://{your-custom-endpoint}.openai.azure.com/
+# azure_deployment: {your-azure-deployment}
+# api_version: {your-api-version}
+# azure_ad_token_provider:
+# provider: autogen_ext.auth.azure.AzureTokenProvider
+# config:
+# provider_kind: DefaultAzureCredential
+# scopes:
+# - https://cognitiveservices.azure.com/.default
\ No newline at end of file