e40056789a
Fixing the HelloWorld sample and some refactoring of .NET code, adding App and Host classes in client and runtime. |
||
|---|---|---|
| .devcontainer | ||
| .github | ||
| docs/design | ||
| dotnet | ||
| protos | ||
| python | ||
| .gitattributes | ||
| .gitignore | ||
| CITATION.cff | ||
| CODE_OF_CONDUCT.md | ||
| CONTRIBUTING.md | ||
| CONTRIBUTORS.md | ||
| LICENSE | ||
| LICENSE-CODE | ||
| README.md | ||
| SECURITY.md | ||
| SUPPORT.md | ||
| TRANSPARENCY_FAQS.md | ||
README.md
AutoGen
[!IMPORTANT] AutoGen 0.4 is a from-the-ground-up rewrite of AutoGen. Learn more about the history, goals and future at this blog post. We’re excited to work with the community to gather feedback, refine, and improve the project before we officially release 0.4. This is a big change, so AutoGen 0.2 is still available, maintained, and developed in the 0.2 branch.
AutoGen is an open-source framework for building AI agent systems. It simplifies the creation of event-driven, distributed, scalable, and resilient agentic applications. It allows you to quickly build systems where AI agents collaborate and perform tasks autonomously or with human oversight.
AutoGen streamlines AI development and research, enabling the use of multiple large language models (LLMs), integrated tools, and advanced multi-agent design patterns. You can develop and test your agent systems locally, then deploy to a distributed cloud environment as your needs grow.
Key Features
AutoGen offers the following key features:
- Asynchronous Messaging: Agents communicate via asynchronous messages, supporting both event-driven and request/response interaction patterns.
- Full type support: use types in all interfaces and enforced type check on build, with a focus on quality and cohesiveness
- Scalable & Distributed: Design complex, distributed agent networks that can operate across organizational boundaries.
- Modular & Extensible: Customize your system with pluggable components: custom agents, tools, memory, and models.
- Cross-Language Support: Interoperate agents across different programming languages. Currently supports Python and .NET, with more languages coming soon.
- Observability & Debugging: Built-in features and tools for tracking, tracing, and debugging agent interactions and workflows, including support for industry standard observability with OpenTelemetry
API Layering
AutoGen has several packages and is built upon a layered architecture. Currently, there are three main APIs your application can target:
Core
The core API of AutoGen, autogen-core, is built following the
actor model.
It supports asynchronous message passing between agents and event-based workflows.
Agents in the core layer handle and produce typed messages, using either direct messaging,
which functions like RPC, or via broadcasting to topics, which is pub-sub.
Agents can be distributed and implemented in different programming languages,
while still communicating with one another.
Start here if you are building scalable, event-driven agentic systems.
AgentChat
The AgentChat API, autogen-agentchat, is task driven and at a high level like AutoGen 0.2.
It allows you to define conversational agents, compose them into teams and then
use them to solve tasks.
AgentChat itself is built on the core layer, but it abstracts away much of its
low-level system concepts.
If your workflows don't fit into the AgentChat API, target core instead.
Start here if you just want to focus on quickly getting started with multi-agents workflows.
Extensions
The extension package autogen-ext contains implementations of the core interfaces using 3rd party systems,
such as OpenAI model client and Azure code executors.
Besides the built-in extensions, the package accommodates community-contributed
extensions through namespace sub-packages.
We look forward to your contributions!
Quickstart
Python (AgentChat)
First install the packages:
pip install autogen-agentchat==0.4.0dev0 autogen-ext==0.4.0dev0
The following code uses code execution, you need to have Docker installed and running on your machine.
from autogen_agentchat.agents import CodeExecutorAgent, CodingAssistantAgent
from autogen_agentchat.teams.group_chat import RoundRobinGroupChat
from autogen_core.components.code_executor import DockerCommandLineCodeExecutor
from autogen_core.components.models import OpenAIChatCompletionClient
async with DockerCommandLineCodeExecutor(work_dir="coding") as code_executor:
code_executor_agent = CodeExecutorAgent("code_executor", code_executor=code_executor)
coding_assistant_agent = CodingAssistantAgent(
"coding_assistant", model_client=OpenAIChatCompletionClient(model="gpt-4o")
)
group_chat = RoundRobinGroupChat([coding_assistant_agent, code_executor_agent])
result = await group_chat.run(
task="Create a plot of NVDIA and TSLA stock returns YTD from 2024-01-01 and save it to 'nvidia_tesla_2024_ytd.png'."
)
print(result)
C#
The .NET SDK does not yet support all of the interfaces that the python SDK offers but we are working on bringing them to parity. To use the .NET SDK, you need to add a package reference to the src in your project. We will release nuget packages soon and will update these instructions when that happens.
git clone https://github.com/microsoft/autogen.git
cd autogen
# Switch to the branch that has this code
git switch staging-dev
# Build the project
cd dotnet && dotnet build AutoGen.sln
# In your source code, add AutoGen to your project
dotnet add <your.csproj> reference <path to your checkout of autogen>/dotnet/src/Microsoft.AutoGen.Agents.Client/Microsoft.AutoGen.Agents.Client.csproj
Then, define your first agent:
using Microsoft.AutoGen.Agents.Abstractions;
using Microsoft.AutoGen.Agents.Client;
namespace HelloAgents.Agents;
[TopicSubscription("HelloAgents")]
public class HelloAgent(
IAgentContext context,
Kernel kernel,
ISemanticTextMemory memory,
[FromKeyedServices("EventTypes")] EventTypes typeRegistry,
ILogger<HelloAgent> logger) : AiAgent<HelloAgentState>(
context,
memory,
kernel,
typeRegistry),
ISayHello,
IHandle<NewMessageReceived>,
IHandle<ConversationClosed>
{
public async Task Handle(NewMessageReceived item)
{
var response = await SayHello(item.Message);
var evt = new ResponseGenerated
{
Response = response
}.ToCloudEvent(this.AgentId.Key);
await PublishEvent(evt);
}
public async Task Handle(ConversationClosed item)
{
var goodbye = "";
var evt = new GoodBye
{
Message = goodbye
}.ToCloudEvent(this.AgentId.Key);
await PublishEvent(evt);
}
public async Task<string> SayHello(string ask)
{
var response = $"Hello {ask}";
return response;
}
}
public interface ISayHello
{
public Task<string> SayHello(string ask);
}
Roadmap
- AutoGen 0.2 - This is the current stable release of AutoGen. We will continue to accept bug fixes and minor enhancements to this version.
- AutoGen 0.4 - This is the first release of the new architecture. This release is still in preview. We will be focusing on the stability of the interfaces, documentation, tutorials, samples, and a collection of built-in agents which you can use. We are excited to work with our community to define the future of AutoGen. We are looking for feedback and contributions to help shape the future of this project. Here are some major planned items:
- More programming languages (e.g., TypeScript)
- More built-in agents and multi-agent workflows
- Deployment of distributed agents
- Re-implementation/migration of AutoGen Studio
- Integration with other agent frameworks and data sources
- Advanced RAG techniques and memory services
FAQs
What is AutoGen 0.4?
AutoGen v0.4 is a rewrite of AutoGen from the ground up to create a more robust, scalable, easier to use, cross-language library for building AI Agents. Some key features include asynchronous messaging, support for scalable distributed agents, modular extensible design (bring your own agents, implement behaviors however you like), cross-language support, improved observability, and full typing integration. It is a breaking change.
Why these changes?
We listened to our AutoGen users, learned from what was working, and adapted to fix what wasn't. We brought together wide-ranging teams working on many different types of AI Agents and collaborated to design an improved framework with a more flexible programming model and better scalability.
Who should use it 0.4?
This code is still experimental, so expect changes and bugs while we work towards a stable 0.4 release. We encourage early adopters to try it out, give us feedback, and contribute. For those looking for a stable version we recommend to continue using 0.2
I'm using AutoGen 0.2, should I upgrade?
If you consider yourself an early adopter, you are comfortable making some changes to your code, and are willing to try it out, then yes.
How do I still use AutoGen 0.2?
AutoGen 0.2 can be installed with:
pip install autogen-agentchat~=0.2
Will AutoGen Studio be supported in 0.4?
Yes, this is on the roadmap. Our current plan is to enable an implementation of AutoGen Studio on the AgentChat high level API which implements a set of agent functionalities (agents, teams, etc).
How do I migrate?
For users familiar with AutoGen, the AgentChat library in 0.4 provides similar concepts. We are working on a migration guide.
What is happening next? When will this release be ready?
We are still working on improving the documentation, samples, and enhancing the code. We are hoping to release before the end of the year when things are ready.
What is the history of this project?
The rearchitecture of the framework started with multiple Microsoft teams coming together to address the gaps and learnings from AutoGen 0.2 - merging ideas from several predecessor projects. The team worked on this internally for some time to ensure alignment before moving work back to the open in October 2024.
What is the official channel for support?
Use GitHub Issues for bug reports and feature requests. Use GitHub Discussions for general questions and discussions.
Legal Notices
Microsoft and any contributors grant you a license to the Microsoft documentation and other content in this repository under the Creative Commons Attribution 4.0 International Public License, see the LICENSE file, and grant you a license to any code in the repository under the MIT License, see the LICENSE-CODE file.
Microsoft, Windows, Microsoft Azure, and/or other Microsoft products and services referenced in the documentation may be either trademarks or registered trademarks of Microsoft in the United States and/or other countries. The licenses for this project do not grant you rights to use any Microsoft names, logos, or trademarks. Microsoft's general trademark guidelines can be found at http://go.microsoft.com/fwlink/?LinkID=254653.
Privacy information can be found at https://go.microsoft.com/fwlink/?LinkId=521839
Microsoft and any contributors reserve all other rights, whether under their respective copyrights, patents, or trademarks, whether by implication, estoppel, or otherwise.