Wie erstellt man Agenten-Chatbots mit AutoGen?

Einführung

Chatbots haben die Artwork und Weise, wie wir mit Technologie umgehen, verändert und automatisierte, intelligente Gespräche über verschiedene Bereiche hinweg ermöglicht. Der Aufbau dieser Chat-Systeme kann eine Herausforderung sein, insbesondere wenn Flexibilität und Skalierbarkeit angestrebt werden. AutoGen vereinfacht diesen Prozess durch den Einsatz von KI-Agenten, die komplexe Dialoge und Aufgaben autonom bearbeiten. In diesem Artikel erfahren Sie, wie Sie mit AutoGen Agenten-Chatbots erstellen. Wir werden sein leistungsstarkes agentenbasiertes Framework erkunden, das die Erstellung adaptiver, intelligenter Konversations-Bots einfacher denn je macht.

Überblick

• Erfahren Sie, worum es beim AutoGen-Framework geht und was es kann.
• Erfahren Sie, wie Sie Chatbots erstellen können, die miteinander diskutieren, auf menschliche Anfragen antworten, im Web suchen und noch mehr tun können.
• Kennen Sie die Einrichtungsanforderungen und Voraussetzungen, die für die Erstellung von Agenten-Chatbots mit AutoGen erforderlich sind.
• Erfahren Sie, wie Sie Chatbots durch die Integration von Instruments wie Tavily für die Websuche verbessern können.

Was ist AutoGen?

In AutoGen werden alle Interaktionen als Gespräche zwischen Agenten modelliert. Diese chatbasierte Kommunikation von Agent zu Agent rationalisiert den Arbeitsablauf und macht es intuitiv, mit der Erstellung von Chatbots zu beginnen. Das Framework bietet außerdem Flexibilität, indem es verschiedene Konversationsmuster wie sequentielle Chats, Gruppenchats und mehr unterstützt.

Lassen Sie uns die AutoGen-Chatbot-Funktionen erkunden, während wir verschiedene Arten von Chatbots erstellen:

1. Dialektik zwischen Agenten: Zwei Experten auf einem Gebiet diskutieren ein Thema und versuchen, ihre Widersprüche aufzulösen.
2. Chatbot zur Interviewvorbereitung: Wir bereiten uns mit einem Agenten auf das Vorstellungsgespräch vor, indem wir Fragen stellen und die Antworten auswerten.
3. Chat mit Internet-Suchtool: Wir können mit einem Suchtool chatten, um beliebige Informationen aus dem Web zu erhalten.

Erfahren Sie mehr: Autogen: Erkundung der Grundlagen eines Multi-Agent-Frameworks

In diesem Artikel verwenden wir OpenAI- und Groq-API-Schlüssel. Groq bietet bis zu einigen kostenlosen Zugriff auf viele Open-Supply-LLMs Tarifgrenzen.

Wir können jedes LLM verwenden, das wir bevorzugen. Beginnen Sie mit der Generierung eines API-Schlüssels für das LLM und Tavily Suchwerkzeug.

Erstellen Sie eine .env-Datei, um diesen Schlüssel sicher zu speichern, ihn privat zu halten und ihn gleichzeitig in Ihrem Projekt leicht zugänglich zu machen.

Bibliotheken erforderlich

Autogen-Agentchat – 0.2.36
Tavily-Python – 0.5.0
groq – 0.7.0
openai – 1.46.0

Dialektik zwischen Agenten

Dialektik ist eine Argumentations- oder Argumentationsmethode, die darauf abzielt, Widersprüche oder gegensätzliche Standpunkte zu untersuchen und aufzulösen. Wir lassen die beiden LLMs mithilfe von AutoGen-Agenten an der Dialektik teilnehmen.

Lassen Sie uns unseren ersten Agenten erstellen:

from autogen import ConversableAgent

agent_1 = ConversableAgent(
    identify="expert_1",
    system_message="""You might be collaborating in a Dialectic about considerations of Generative AI with one other knowledgeable. 
                    Make your factors on the thesis concisely.""",
    llm_config={"config_list": ({"mannequin": "gpt-4o-mini", "temperature": 0.5})},
    code_execution_config=False,
    human_input_mode="NEVER", 
)

Code-Erklärung

• ConversableAgent: Dies ist die Basisklasse zum Erstellen anpassbarer Agenten, die mit anderen Agenten, Personen und Instruments sprechen und interagieren können, um Aufgaben zu lösen.
• Systemmeldung: Der Parameter system_message definiert die Rolle und den Zweck des Agenten in der Konversation. In diesem Fall wird Agent_1 angewiesen, sich auf eine Dialektik über generative KI einzulassen und die These prägnant darzulegen.
• llm_config: Diese Konfiguration legt das zu verwendende Sprachmodell fest, hier „gpt-4o-mini“. Zusätzliche Parameter wie Temperatur = 0,5 werden eingestellt, um die Antwortkreativität und -variabilität des Modells zu steuern.
• code_execution_config=False: Dies weist darauf hin, dass für den Agent keine Codeausführungsfunktionen aktiviert sind.
• human_input_mode=“NIEMALS“: Diese Einstellung stellt sicher, dass der Agent nicht auf menschliche Eingaben angewiesen ist und völlig autonom arbeitet.

Jetzt der zweite Agent

agent_2 = ConversableAgent(
    "expert_2",
    system_message="""You might be collaborating in a Dialectic about considerations of Generative AI with one other knowledgeable. Make your factors on the anti-thesis concisely.""",
    llm_config={"config_list": ({"api_type": "groq", "mannequin": "llama-3.1-70b-versatile", "temperature": 0.3})},
    code_execution_config=False, 
    human_input_mode="NEVER",  
)

Hier verwenden wir das Modell Llama 3.1 von Groq. Um zu erfahren, wie man verschiedene LLMs einstellt, können wir hier nachlesen Hier.

Lassen Sie uns den Chat starten:

outcome = agent_1.initiate_chat(agent_2, message="""The character of knowledge assortment for coaching AI fashions pose inherent privateness dangers""", 
max_turns=3, silent=False, summary_method="reflection_with_llm")

Code-Erklärung

In diesem Code initiiert Agent_1 mithilfe der bereitgestellten Nachricht eine Konversation mit Agent_2.

• max_turns=3: Dadurch wird das Gespräch auf drei Austausche zwischen den Agenten beschränkt, bevor es automatisch beendet wird.
• nonetheless=Falsch: Dadurch wird die Konversation in Echtzeit angezeigt.
• summary_method=’reflection_with_llm‘: Hierbei wird ein großes Sprachmodell (LLM) verwendet, um den gesamten Dialog zwischen den Agenten nach Abschluss des Gesprächs zusammenzufassen und so eine reflektierende Zusammenfassung ihrer Interaktion bereitzustellen.

Sie können die gesamte Dialektik mit der Methode chat_history durchgehen.

Hier ist das Ergebnis:

len(outcome.chat_history)
>>> 6
# every agent has 3 replies.

# we are able to additionally verify the price incurred
print(outcome.price)

# get chathistory
print(outcome.chat_history)

# lastly abstract of the chat
print(outcome.abstract('content material'))

Chatbot zur Vorbereitung auf Vorstellungsgespräche

Wir können nicht nur zwei Agenten untereinander chatten lassen, sondern auch mit einem KI-Agenten chatten. Versuchen wir dies, indem wir einen Agenten erstellen, der zur Vorbereitung auf Vorstellungsgespräche verwendet werden kann.

interviewer = ConversableAgent(
    "interviewer",
    system_message="""You might be interviewing to pick for the Generative AI intern place. 
    Ask appropriate questions and consider the candidate.""",
    llm_config={"config_list": ({"api_type": "groq", "mannequin": "llama-3.1-70b-versatile", "temperature": 0.0})},
    code_execution_config=False,
    human_input_mode="NEVER",
    # max_consecutive_auto_reply=2,
    is_termination_msg=lambda msg: "goodbye" in msg("content material").decrease()
)

Code-Erklärung

Verwenden Sie system_message, um die Rolle des Agenten zu definieren.

Um die Konversation zu beenden, können wir einen der beiden folgenden Parameter verwenden:

• max_consecutive_auto_reply: Dieser Parameter begrenzt die Anzahl aufeinanderfolgender Antworten, die ein Agent senden kann. Sobald der Agent diese Grenze erreicht, wird das Gespräch automatisch beendet, sodass es nicht auf unbestimmte Zeit fortgesetzt werden kann.
• is_termination_msg: Dieser Parameter prüft, ob eine Nachricht ein bestimmtes vordefiniertes Schlüsselwort enthält. Wenn dieses Schlüsselwort erkannt wird, wird die Konversation automatisch beendet.

candidate = ConversableAgent(
    "candidate",
    system_message="""You might be attending an interview for the Generative AI intern place. 
    Reply the questions accordingly""",
    llm_config=False,
    code_execution_config=False,
    human_input_mode="ALWAYS",
)

Da der Benutzer die Antwort geben wird, verwenden wir human_input_mode=“ALWAYS“ und llm_config=False

Jetzt können wir das Scheininterview initialisieren:

outcome = candidate.initiate_chat(interviewer, message="Hello, thanks for calling me.", summary_method="reflection_with_llm")

# we are able to get the abstract of the dialog too
print(outcome.abstract)

Chatten Sie mit der Websuche

Lassen Sie uns nun einen Chatbot erstellen, der das Web nutzen kann, um nach den gestellten Fragen zu suchen.

Definieren Sie dazu zunächst eine Funktion, die das Internet mit Tavily durchsucht.

from tavily import TavilyClient
from autogen import register_function

def web_search(question: str):
    tavily_client = TavilyClient()
    response = tavily_client.search(question, max_results=3)
    return response('outcomes')

Ein stellvertretender Agent, der entscheidet, das Software aufzurufen oder zu beenden

assistant = ConversableAgent(
    identify="Assistant",
    system_message="""You're a useful AI assistant. You'll be able to search net to get the outcomes. 
    Return 'TERMINATE' when the duty is completed.""",
    llm_config={"config_list": ({"mannequin": "gpt-4o-mini"})},
    silent=True,
)

Der Benutzer-Proxy-Agent wird für die Interaktion mit dem Assistenten-Agenten verwendet und führt Software-Aufrufe aus.

user_proxy = ConversableAgent(
    identify="Consumer",
    llm_config=False,
    is_termination_msg=lambda msg: msg.get("content material") just isn't None and "TERMINATE" in msg("content material"),
    human_input_mode="TERMINATE",
)

Wenn die Beendigungsbedingung erfüllt ist, wird eine menschliche Eingabe angefordert. Wir können entweder weiter abfragen oder den Chat beenden.

Registrieren Sie die Funktion für die beiden Agenten:

register_function(
    web_search,
    caller=assistant,  # The assistant agent can recommend calls to the calculator.
    executor=user_proxy,  # The consumer proxy agent can execute the calculator calls.
    identify="web_search",  # By default, the perform identify is used because the software identify.
    description="Searches web to get the outcomes a for given question",  # An outline of the software.
)

Jetzt können wir abfragen:

chat_result = user_proxy.initiate_chat(assistant, message="Who gained the Nobel prizes in 2024")

# Relying on the size of the chat historical past we are able to entry the required content material
print(chat_result.chat_history(5)('content material'))

Auf diese Weise können wir mit AutoGen verschiedene Arten von Agenten-Chatbots erstellen.

Lesen Sie auch: Strategisches Teambuilding mit AutoGen AI

Um KI-Agenten zu beherrschen, schauen Sie sich unsere an Agentisches KI-Pionierprogramm.

Häufig gestellte Fragen

Ich arbeite als Affiliate Knowledge Scientist bei Analytics Vidhya, einer Plattform, die sich dem Aufbau des Knowledge Science-Ökosystems widmet. Meine Interessen liegen in den Bereichen Pure Language Processing (NLP), Deep Studying und KI-Agenten.