AutoGen Multi-Agent Framework Cheat Sheet¶
Im Überblick
AutoGen ist ein bahnbrechendes Open-Source-Framework, das von Microsoft Research entwickelt wurde, das die Entwicklung von Large Language Model (LLM) Anwendungen revolutioniert, indem er anspruchsvolle multiagente Gespräche ermöglicht. Im Gegensatz zu herkömmlichen Single-Agent-Systemen ermöglicht AutoGen Entwicklern, komplexe Anwendungen zu erstellen, indem mehrere spezialisierte KI-Agenten, die miteinander konversieren können, an Aufgaben zusammenarbeiten und sogar Menschen in der Schleife nahtlos einbeziehen.
Was AutoGen besonders mächtig macht, ist sein Schwerpunkt auf Gespräch als primärer Mechanismus für Agenteninteraktion. Dieser Ansatz ermöglicht eine natürliche, flexible und dynamische Zusammenarbeit zwischen Agenten und spiegelt wider, wie menschliche Teams zusammenarbeiten, um komplexe Probleme zu lösen. AutoGen bietet eine reiche Reihe von Werkzeugen zur Definition von Agentenrollen, Fähigkeiten und Kommunikationsprotokollen, so dass es möglich ist, hochanpassungsfähige und intelligente Systeme zu bauen, die eine breite Palette von Aufgaben bewältigen können, von Codegenerierung und Datenanalyse bis hin zu kreativem Schreiben und strategischer Planung.
Der Rahmen ist sowohl für Einfachheit als auch für Erweiterbarkeit ausgelegt und bietet hochrangige Abstraktionen für gemeinsame multiagente Muster und bietet gleichzeitig tiefe Anpassungsmöglichkeiten für fortgeschrittene Anwendungsfälle. Mit seiner ereignisgetriebenen Architektur und Unterstützung für verschiedene LLMs und Tools ermöglicht AutoGen Entwicklern, KI-Anwendungen der nächsten Generation aufzubauen, die leistungsfähiger, robuster und human ausgerichtet sind als je zuvor.
Installation und Inbetriebnahme
Grundinstallation¶
# Install AutoGen
pip install pyautogen
# Install with specific integrations (e.g., OpenAI)
pip install "pyautogen[openai]"
# Install development version
pip install git+https://github.com/microsoft/autogen.git
# Install with all optional dependencies
pip install "pyautogen[all]"
```_
### Umweltkonfiguration
```python
import os
import autogen
# Configure LLM provider (OpenAI example)
config_list_openai = [
\\\\{
"model": "gpt-4",
"api_key": os.environ.get("OPENAI_API_KEY")
\\\\},
\\\\{
"model": "gpt-3.5-turbo",
"api_key": os.environ.get("OPENAI_API_KEY")
\\\\}
]
# Configure for other LLMs (e.g., Azure OpenAI, local models)
# See AutoGen documentation for specific configurations
# Set up logging
autogen.ChatCompletion.set_cache(seed=42) # For reproducibility
```_
### Projektstruktur
Kernkonzepte
Agents¶
Agenten sind die grundlegenden Bausteine in AutoGen. Sie sind Konversationseinheiten, die Nachrichten senden und empfangen können, Code ausführen, Call-Funktionen und interagieren mit Menschen.
ConversableAgent¶
Dies ist die Basisklasse für die meisten Agenten in AutoGen, bietet Kernkonversationsfunktionen.
UserProxyAgent¶
Ein spezialisierter Agent, der als Proxy für menschliche Benutzer fungiert, so dass sie an Gesprächen teilnehmen, Eingabe und Code ausführen.
AssistantAgent¶
Ein Agent, der als KI-Assistent fungiert, typischerweise von einem LLM betrieben, in der Lage, Code zu schreiben, Fragen zu beantworten und Aufgaben zu erfüllen.
GroupChat¶
AutoGen unterstützt multiagente Gespräche durch GroupChat und GroupChatManager und ermöglicht komplexe Interaktionen zwischen mehreren Agenten.
Agent Configuration
Grundlegende Agentenerstellung¶
```python import autogen
Assistant Agent (LLM-powered)¶
assistant = autogen.AssistantAgent( name="Assistant", llm_config=\\{ "config_list": config_list_openai, "temperature": 0.7, "timeout": 600 \\}, system_message="You are a helpful AI assistant. Provide concise and accurate answers." )
User Proxy Agent (Human in the loop)¶
user_proxy = autogen.UserProxyAgent( name="UserProxy", human_input_mode="TERMINATE", # Options: ALWAYS, TERMINATE, NEVER max_consecutive_auto_reply=10, is_termination_msg=lambda x: x.get("content", "").rstrip().endswith("TERMINATE"), code_execution_config=\\{ "work_dir": "coding_output", "use_docker": False # Set to True to use Docker for code execution \\}, system_message="A human user. Reply TERMINATE when the task is done or if you want to stop." ) ```_
Advanced Agent Customization¶
```python import autogen
Agent with custom reply function¶
def custom_reply_func(messages, sender, config): last_message = messages[-1]["content"] if "hello" in last_message.lower(): return "Hello there! How can I help you today?" return "I received your message."
custom_agent = autogen.ConversableAgent( name="CustomAgent", llm_config=False, # No LLM for this agent reply_func_list=[custom_reply_func] )
Agent with specific skills (function calling)¶
@autogen.register_function( name="get_stock_price", description="Get the current stock price for a given symbol.", parameters=\\{"symbol": \\{"type": "string", "description": "Stock symbol"\\}\\} ) def get_stock_price(symbol: str) -> str: # Implement stock price retrieval logic return f"The price of \\{symbol\\} is $150."
stock_analyst_agent = autogen.AssistantAgent( name="StockAnalyst", llm_config=\\{ "config_list": config_list_openai, "functions": [autogen.AssistantAgent.construct_function_description(get_stock_price)] \\}, function_map=\\{"get_stock_price": get_stock_price\\} ) ```_
Specialized Agent Types¶
```python import autogen
TeachableAgent for learning from feedback¶
teachable_agent = autogen.TeachableAgent( name="TeachableAnalyst", llm_config=\\{"config_list": config_list_openai\\}, teach_config=\\{ "verbosity": 0, # 0 for no teaching, 1 for normal, 2 for detailed "reset_db": False, # Set to True to clear previous learnings "path_to_db_dir": "./teachable_agent_db" \\} )
RetrieveUserProxyAgent for RAG (Retrieval Augmented Generation)¶
rag_agent = autogen.retrieve_chat.RetrieveUserProxyAgent( name="RAGAgent", human_input_mode="TERMINATE", retrieve_config=\\{ "task": "qa", "docs_path": "./documents_for_rag", "chunk_token_size": 2000, "model": config_list_openai[0]["model"], "collection_name": "rag_collection", "get_or_create": True \\} ) ```_
Ansprechpartner
Two-Agent Chat¶
```python import autogen
Initiate chat between user_proxy and assistant¶
user_proxy.initiate_chat( assistant, message="What is the capital of France?", summary_method="reflection_with_llm", # For summarizing conversation history max_turns=5 )
Example with code execution¶
user_proxy.initiate_chat( assistant, message="Write a Python script to print numbers from 1 to 5 and run it." ) ```_
Gruppen Chat mit mehreren Agenten¶
```python import autogen
Define agents for group chat¶
planner = autogen.AssistantAgent( name="Planner", llm_config=\\{"config_list": config_list_openai\\}, system_message="You are a project planner. Create detailed plans for tasks." )
engineer = autogen.AssistantAgent( name="Engineer", llm_config=\\{"config_list": config_list_openai\\}, system_message="You are a software engineer. Implement the plans provided." )
reviewer = autogen.AssistantAgent( name="Reviewer", llm_config=\\{"config_list": config_list_openai\\}, system_message="You are a code reviewer. Review the implemented code for quality." )
Create group chat and manager¶
group_chat = autogen.GroupChat( agents=[user_proxy, planner, engineer, reviewer], messages=[], max_round=12, speaker_selection_method="auto" # auto, round_robin, random, manual )
manager = autogen.GroupChatManager( groupchat=group_chat, llm_config=\\{"config_list": config_list_openai\\} )
Initiate group chat¶
user_proxy.initiate_chat( manager, message="Develop a Python script to calculate Fibonacci numbers up to n." ) ```_
Advanced Conversation Control¶
```python import autogen
Custom speaker selection¶
def custom_speaker_selector(last_speaker, groupchat): if last_speaker is user_proxy: return planner elif last_speaker is planner: return engineer elif last_speaker is engineer: return reviewer else: return user_proxy
custom_group_chat = autogen.GroupChat( agents=[user_proxy, planner, engineer, reviewer], messages=[], speaker_selection_method=custom_speaker_selector )
Nested chats¶
def initiate_nested_chat(recipient, message): user_proxy.initiate_chat(recipient, message=message, clear_history=False)
Example of agent calling nested chat¶
class MainAgent(autogen.AssistantAgent): def generate_reply(self, messages, sender, **kwargs): # ... logic ... if needs_specialized_help: initiate_nested_chat(specialist_agent, "Need help with this sub-task.") # ... process specialist_agent response ... return "Main task processed." ```_
Werkzeug- und Funktionsintegration
Verwenden von integrierten Tools¶
AutoGen hat nicht eine große Reihe von vorgefertigten Werkzeugen wie einige andere Frameworks. Stattdessen konzentriert es sich auf die Freigabe von Agenten, um Code (Python-Skripte, Shell-Befehle) auszuführen, die dann mit jeder Bibliothek oder Werkzeug in der Ausführungsumgebung interagieren können.
Custom Function Calling (Skills)¶
```python import autogen
Define a function (skill)¶
@autogen.register_function def get_weather(location: str) -> str: """Get the current weather for a given location.""" # Replace with actual API call if location == "London": return "Weather in London is 15°C and cloudy." elif location == "Paris": return "Weather in Paris is 18°C and sunny." else: return f"Weather data not available for \\{location\\}."
Agent that can use the function¶
weather_assistant = autogen.AssistantAgent( name="WeatherAssistant", llm_config=\\{ "config_list": config_list_openai, "functions": [autogen.AssistantAgent.construct_function_description(get_weather)] \\}, function_map=\\{"get_weather": get_weather\\} )
User proxy to trigger function call¶
user_proxy.initiate_chat( weather_assistant, message="What is the weather in London?" ) ```_
Code Execution¶
```python import autogen
UserProxyAgent is configured for code execution by default¶
Ensure code_execution_config is set appropriately¶
Example: Agent asks UserProxyAgent to execute code¶
coder_agent = autogen.AssistantAgent( name="Coder", llm_config=\\{"config_list": config_list_openai\\} )
user_proxy.initiate_chat( coder_agent, message="Write a Python script that creates a file named 'test.txt' with content 'Hello AutoGen!' and then execute it." )
UserProxyAgent will prompt for confirmation before executing the code.¶
```_
Mensch-in-the-Loop (HIL)
Human Input konfigurieren¶
```python import autogen
UserProxyAgent configured for human input¶
hil_user_proxy = autogen.UserProxyAgent( name="HumanReviewer", human_input_mode="ALWAYS", # ALWAYS: Human input required for every message # TERMINATE: Human input required if no auto-reply, or to terminate # NEVER: No human input (fully autonomous) is_termination_msg=lambda x: x.get("content", "").rstrip() == "APPROVE" )
Example workflow with human review¶
planner = autogen.AssistantAgent(name="Planner", llm_config=llm_config) executor = autogen.AssistantAgent(name="Executor", llm_config=llm_config)
groupchat_with_review = autogen.GroupChat( agents=[hil_user_proxy, planner, executor], messages=[], max_round=10 ) manager_with_review = autogen.GroupChatManager( groupchat=groupchat_with_review, llm_config=llm_config )
hil_user_proxy.initiate_chat( manager_with_review, message="Plan and execute a task to summarize a long document. I will review the plan and the final summary." ) ```_
Asynchron Human Input¶
AutoGen behandelt hauptsächlich HIL synchron innerhalb des Gesprächsflusses. Für komplexere asynchrone HIL würden Sie typischerweise mit externen Task-Management- oder UI-Systemen integrieren.
Erweiterte Eigenschaften
Teachable Agents¶
```python import autogen
Setup TeachableAgent¶
teachable_coder = autogen.TeachableAgent( name="TeachableCoder", llm_config=\\{"config_list": config_list_openai\\}, teach_config=\\{ "verbosity": 1, "reset_db": False, "path_to_db_dir": "./teachable_coder_db", "recall_threshold": 1.5, # Higher value means less recall \\} )
User teaches the agent¶
user_proxy.initiate_chat( teachable_coder, message="When I ask for a quick sort algorithm, always implement it in Python using a recursive approach." )
Later, the agent uses the learned information¶
user_proxy.initiate_chat( teachable_coder, message="Implement a quick sort algorithm." )
To clear learnings:¶
teachable_coder.clear_mem L() # For in-memory (if not using DB)¶
Or set teach_config["reset_db"] = True and re-initialize¶
```_
Retrieval Augmented Generation (RAG)¶
```python import autogen from autogen.agentchat.contrib.retrieve_assistant_agent import RetrieveAssistantAgent
Ensure you have a directory with documents (e.g., ./my_documents)¶
Supported formats: .txt, .md, .pdf, .html, .htm, .json, .jsonl, .csv, .tsv, .xls, .xlsx, .doc, .docx, .ppt, .pptx, .odt, .rtf, .epub¶
Create a RetrieveAssistantAgent (combines LLM with retrieval)¶
retrieval_assistant = RetrieveAssistantAgent( name="RetrievalAssistant", system_message="You are a helpful assistant that answers questions based on provided documents.", llm_config=\\{"config_list": config_list_openai\\} )
Create a RetrieveUserProxyAgent to handle document processing and querying¶
rag_user_proxy = autogen.retrieve_chat.RetrieveUserProxyAgent( name="RAGUserProxy", human_input_mode="TERMINATE", max_consecutive_auto_reply=5, retrieve_config=\\{ "task": "qa", # Can be "qa", "code", "chat" "docs_path": "./my_documents", # Path to your documents "chunk_token_size": 2000, "model": config_list_openai[0]["model"], "collection_name": "my_rag_collection", "get_or_create": True, # Creates collection if it doesn_t exist "embedding_model": "all-mpnet-base-v2" # Example sentence transformer model \\}, code_execution_config=False )
Initiate RAG chat¶
The RAGUserProxy will first try to answer from documents, then pass to RetrievalAssistant if needed.¶
rag_user_proxy.initiate_chat( retrieval_assistant, problem="What are the main features of AutoGen according to the documents?" )
To update or add new documents, you might need to re-index or manage the collection.¶
rag_user_proxy.retrieve_config["update_context"] = True (for some RAG setups)¶
```_
Multi-Modal Conversations¶
AutoGen unterstützt multimodale Eingaben (z.B. Bilder), wenn die zugrunde liegende LLM sie unterstützt (wie GPT-4V). ```python import autogen
Ensure your config_list points to a multimodal LLM (e.g., gpt-4-vision-preview)¶
multimodal_config_list = [ \\{ "model": "gpt-4-vision-preview", "api_key": os.environ.get("OPENAI_API_KEY") \\} ]
multimodal_agent = autogen.AssistantAgent( name="MultimodalAgent", llm_config=\\{"config_list": multimodal_config_list\\} )
Example message with an image URL¶
user_proxy.initiate_chat( multimodal_agent, message=[ \\{"type": "text", "text": "What is in this image?"\\}, \\{"type": "image_url", "image_url": \\{"url": "https://example.com/image.jpg"\\}\\} ] )
Example with local image (requires proper handling to make it accessible to the LLM)¶
This might involve uploading the image or using a local multimodal LLM setup.¶
For local images with OpenAI, you typically need to base64 encode them.¶
import base64
def image_to_base64(image_path): with open(image_path, "rb") as img_file: return base64.b64encode(img_file.read()).decode("utf-8")
local_image_path = "./path_to_your_image.png" base64_image = image_to_base64(local_image_path)
user_proxy.initiate_chat( multimodal_agent, message=[ \\{"type": "text", "text": "Describe this local image:"\\}, \\{"type": "image_url", "image_url": \\{"url": f"data:image/png;base64,\\{base64_image\\}"\\}\\} ] ) ```_
Agent Workflow Muster
Reflexion und Selbstdarstellung¶
```python import autogen
Agent that reflects on its own output¶
self_reflecting_agent = autogen.AssistantAgent( name="Reflector", llm_config=\\{"config_list": config_list_openai\\}, system_message="You are an AI that writes code. After writing code, reflect on its quality and correctness. If you find issues, try to correct them." )
User proxy to facilitate reflection¶
reflection_user_proxy = autogen.UserProxyAgent( name="ReflectionProxy", human_input_mode="NEVER", max_consecutive_auto_reply=3, # Allow a few turns for reflection # Custom message to trigger reflection or provide feedback # This often involves a more complex setup where the proxy or another agent critiques the output. )
This pattern is often implemented with a sequence of chats or a GroupChat¶
where one agent produces work and another critiques it, then the first agent revises.¶
Simplified example:¶
user_proxy.initiate_chat( self_reflecting_agent, message="Write a Python function to calculate factorial. Then, review your code for potential bugs or improvements and provide a revised version if necessary." ) ```_
Hierarchical Agent Teams¶
Dies wird typischerweise mit GroupChatManager erreicht, wo ein Agent (z.B. ein Manager oder Planer) andere spezialisierte Agenten koordiniert. ```python import autogen
Manager Agent¶
manager_agent = autogen.AssistantAgent( name="Manager", llm_config=\\{"config_list": config_list_openai\\}, system_message="You are a project manager. Delegate tasks to your team (Engineer, Researcher) and synthesize their results." )
Specialist Agents¶
engineer_agent = autogen.AssistantAgent(name="Engineer", llm_config=llm_config) researcher_agent = autogen.AssistantAgent(name="Researcher", llm_config=llm_config)
Group Chat for the team¶
team_groupchat = autogen.GroupChat( agents=[user_proxy, manager_agent, engineer_agent, researcher_agent], messages=[], max_round=15, # Manager agent can be set to speak or select next speaker speaker_selection_method=lambda last_speaker, groupchat: manager_agent if last_speaker != manager_agent else user_proxy # Simplified example )
team_manager = autogen.GroupChatManager( groupchat=team_groupchat, llm_config=llm_config )
user_proxy.initiate_chat( team_manager, message="Develop a new feature for our app that requires research on user needs and then engineering implementation." ) ```_
oder Best Practices
Agent Design¶
Clear Roles: Definieren Sie spezifische, eindeutige Rollen und Verantwortlichkeiten für jeden Agenten. - Systemnachrichten*: Verwenden Sie detaillierte Systemnachrichten, um Agentverhalten und persona zu führen. - **Tool Access: Agenten nur mit den Werkzeugen versorgen, die sie für ihre Rolle benötigen. - **LLM Konfiguration*: Maßgeschneiderte LLM-Temperatur, Modell und andere Einstellungen pro Agent für optimale Leistung.
Konversation Management¶
Terminationsbedingungen*: Deutlich definieren, wann ein Gespräch oder eine Aufgabe abgeschlossen ist. - **Max Turns/Rounds*: Grenzen setzen, um unendliche Schleifen oder übermäßige Kosten zu verhindern. - **Speaker Selection: Wählen Sie geeignete Auswahlmethoden für Gruppenchats (auto, round_robin, custom). - **Summarisierung*: Verwenden Sie Konversationszusammenfassung für langlaufende Chats, um Kontextfenster zu verwalten.
Code Execution Security¶
- **Sandboxing*: Verwenden Sie Docker (
use_docker=Trueincode_execution_config) für eine sicherere Codeausführung, insbesondere mit nicht vertrauenswürdigem Code. - **Human Review*: Implementieren Sie die menschliche Bewertung (__INLINE_CODE_19_ oder
"TERMINATE"), bevor Sie potenziell riskanten Code ausführen. - **Einschränkte Umwelt*: Wenn Sie Docker nicht verwenden, stellen Sie sicher, dass die Ausführung Umgebung begrenzte Berechtigungen hat.
Kostenmanagement¶
- Auswahl: Verwenden Sie weniger teure Modelle (z.B. GPT-3.5-turbo) für einfachere Aufgaben oder Agenten.
- **Max Tokens/Turns*: Beschränken Sie die Länge der Gespräche und LLM Ausgänge.
- Caching: Verwenden Sie
autogen.ChatCompletion.set_cache(), um LLM-Antworten zu speichern und redundante Anrufe zu reduzieren. - Monitoring: Track Token Nutzung und API Kosten eng.
Debugging¶
- **Verbose Logging*: AutoGen bietet Protokollierung; erhöhen Verbenheit für Debugging.
- Step-by-Step Execution: Für komplexe Gruppenchats sollten Sie manuelle Lautsprecherauswahl oder Breakpoints beachten, um Flow zu verstehen.
- ** Agent Isolation**: Testmittel einzeln vor der Integration in größere Gruppen.
Fehlerbehebung
Häufige Fragen¶
Agenten Stuck in Loops
- Cause: Vague Kündigungsbedingungen, Konfliktziele oder übermäßig komplexe Interaktionen.
- Solution: Refine is_termination_msg Lambda, vereinfachte Agentenanweisungen, eingestellt __INLINE_CODE_23_ oder max_round
Unerwartete Agent Behavior - Cause: Mehrdeutige Systemnachrichten, LLM-Fehlerinterpretationen oder falsche LLM-Konfigurationen. - Solution: Systemnachrichten genauer machen, mit unterschiedlichen LLM-Temperaturen experimentieren, korrekte Funktion/Werkzeugbeschreibungen sicherstellen.
Code Execution Failure - Cause: Fehlende Abhängigkeiten in der Ausführungsumgebung, falscher Code, der von LLM generiert wird, Berechtigungsprobleme. - Solution: Stellen Sie sicher, dass alle notwendigen Pakete installiert sind (oder verwenden Sie Docker), verbessern Sie die Eingabeaufforderungen für die Codegenerierung, überprüfen Sie die Datei/Netzwerkberechtigungen.
Funktion Calling Probleme - Cause: Falsche Funktionsbeschreibungen für LLM, Bugs im benutzerdefinierten Funktionscode, LLM scheitert, gültige JSON für Argumente zu generieren. - Solution: Stellen Sie sicher, dass Funktionsbeschreibungen klar und übereinstimmen, testen Sie benutzerdefinierte Funktionen gründlich, verfeinern Sie Eingabeaufforderungen, um LLM in Richtung korrektes JSON-Format zu führen.
--
*Dieses AutoGen-Betrug-Blatt bietet einen umfassenden Leitfaden für den Aufbau anspruchsvoller multiagent AI-Anwendungen. Durch die Nutzung von AutoGen_s Konversationsrahmen können Entwickler hochfähige und kollaborative KI-Systeme erstellen. Denken Sie daran, die offizielle AutoGen Dokumentation für die neuesten Funktionen und detaillierte API Referenzen zu konsultieren. *