Auf Wiedersehen LangChain, Atomic Agents ist in Flammen! -Chef AI Sharing Circle

ähnelnLangChain, undCrewAIim Gesang antwortenAutoGenSolche Frameworks sind beliebt, da sie hochgradige Abstraktionen für den Aufbau von KI-Systemen bieten. Viele Entwickler, darunter auch ich, haben jedoch festgestellt, dass diese Tools mehr schaden als nützen und den Entwicklungsprozess oft unnötig kompliziert und frustrierend machen.

gehen inAtomare Wirkstoffe- Atomic Agents ist ein modulares, rationalisiertes Framework, das die Probleme im Zusammenhang mit bestehenden KI-Entwicklungstools beseitigt. Atomic Agents basiert auf zuverlässigen Programmierparadigmen wie Input-Prozess-Output-Modell (IPO)im Gesang antwortenAtomaritätKonzept und bietet einen neuen Ansatz, bei dem Einfachheit, Flexibilität und Kontrolle durch den Entwickler im Vordergrund stehen.

In diesem Artikel werfen wir einen genaueren Blick darauf, warum Atomic Agents entwickelt wurde, welches Programmierparadigma es verwendet und wie es sich von der Masse abhebt. Werfen Sie einen Blick auf Atomic Agents mit Code-Beispielen und Beispielen aus der Praxis. Und wenn Sie schon immer dachten, dass LangChain zu kompliziert ist, dann schauen Sie es sich hier gemeinsam an!

Probleme mit bestehenden KI-Rahmenwerken

Als ich anfing, mit folgenden Themen zu experimentierenLangChainDamals war ich sehr daran interessiert, dass es die Entwicklung von KI-Agenten vereinfacht. Aber so einfach ist es eigentlich nicht.

Abgesehen von der Komplexität der Klassen und Methoden scheinen die Entwickler von LangChain die praktischen Herausforderungen der KI-Entwicklung nicht zu verstehen, vielleicht schätzen sie die theoretische Eleganz mehr als die praktische Nutzbarkeit. Übermäßige Abstraktion macht die Entwicklung nicht nur schwieriger, sondern auch undurchsichtig.

Magische Illusionen in CrewAI und AutoGen

Gleichermaßen.CrewAIim Gesang antwortenAutoGenFrameworks wie diese versuchen auch, "magische" Lösungen zu bieten, indem sie komplexe Aufgaben automatisieren. Die Vorstellung, Schwärme von KI-Agenten einzusetzen, die alles autonom erledigen, ist verlockend, aber in der Praxis funktionieren diese Tools oft nicht einmal die Hälfte der Zeit richtig. Sie versprechen zu viel und halten in der Praxis zu wenig, so dass die Entwickler mit unvorhersehbarem Verhalten und mangelnder Kontrolle überfordert sind.

Diese Frameworks verwischen die zugrundeliegenden Prozesse und erschweren das Debuggen oder Anpassen von Funktionen. Das Ergebnis ist, dass diese Tools eher eine Blackbox als ein nützliches Framework sind - nicht ideal für die Entwicklung von Anwendungen, die Zuverlässigkeit und Wartbarkeit erfordern.

Die Funktion der Überverpflichtung: Häufig gestellte Fragen

Ein immer wiederkehrendes Problem bei diesen Rahmenwerken ist die Tendenz, dassFunktion der Überverpflichtung. Einige Unternehmen und Tools behaupten, Lösungen anzubieten, die nahe an AGI (Artificial General Intelligence) heranreichen, aber wenn Sie eine lange Karriere im Bereich der KI hinter sich haben, werden Sie feststellen, dass wir noch nicht so weit sind. Der Hype führt oft zu unrealistischen Erwartungen, und wenn diese Tools unweigerlich versagen, müssen die Entwickler die Konsequenzen tragen.

Wir brauchen einen besseren Weg

Nachdem wir mit diesen Rückschlägen gerungen hatten, wurde uns klar, dass wir einen solchen Rahmen brauchen:Beseitigung von unnötiger Komplexitätund Abstraktionsebenen:

Beseitigung von unnötiger Komplexitätund Abstraktionsebenen.
Volle Kontrolle für Entwicklerohne die wichtigsten Funktionen hinter undurchsichtigen Schnittstellen zu verstecken.
Befolgen Sie zuverlässige, bewährte Programmierparadigmenzur Verbesserung der Wartbarkeit und Skalierbarkeit.
Von Entwicklern für Entwickler entwickeltdie praktischen Herausforderungen bei der KI-Entwicklung zu verstehen.

Dieses Verständnis hat dazu geführt, dassAtomare WirkstoffeDie Geburt von.

Einführung in atomare Wirkstoffe

Atomic Agents Logo

Atomare Wirkstoffeist ein Open-Source-Framework, das so leichtgewichtig, modular und komponierbar wie möglich sein soll. Es folgt demInput-Processing-Output-Modell (IPO)im Gesang antwortenAtomaritätPrinzipien, die sicherstellen, dass jede Komponente für einen einzigen Zweck geeignet, wiederverwendbar und austauschbar ist.

Warum gibt es Atomare Agenten?

Atomare Wirkstoffe wurde geschaffen, um die Lücken der bestehenden Rahmenwerke zu schließen. Er zielt darauf ab

Durch die Bereitstellung klarer, überschaubarer Komponenten.Vereinfachung der Entwicklung künstlicher Intelligenz.
Beseitigung der überflüssigen Komplexität, die andere Frameworks plagtund unnötige Abstraktionen.
Förderung von Flexibilität und KohärenzDadurch können sich Entwickler auf die Entwicklung effektiver KI-Anwendungen konzentrieren, anstatt sich mit dem Framework selbst zu beschäftigen.
Förderung bewährter PraktikenDie Entwickler werden dazu angehalten, eine modulare und wartbare Codestruktur zu verwenden.

Durch die Einhaltung dieser Prinzipien ermöglicht Atomic Agents Entwicklern, KI-Agenten und -Anwendungen zu erstellen, die sowohl leistungsstark als auch einfach zu verwalten sind.

Das Programmierparadigma hinter atomaren Agenten

Input-Prozess-Output-Modell (IPO)

Das Herzstück von Atomic Agents ist dieInput-Prozess-Output-Modell (IPO)Es handelt sich um ein grundlegendes Programmierparadigma, das die Struktur eines Programms in drei verschiedene Phasen unterteilt:

EingabeEmpfangen von Daten von Benutzern oder anderen Systemen.
ProzessVerarbeitung oder Konvertierung von Daten.
AusgabeDie verarbeiteten Daten werden als Ergebnisse dargestellt.

Dieses Modell ist klar und prägnant und erleichtert das Verständnis und die Verwaltung des Datenflusses in einer Anwendung.

In Atomic Agents bedeutet dies

Eingabe-SchemataPydantic: Verwenden Sie Pydantic, um die Struktur der Eingabedaten und Validierungsregeln zu definieren.
Verarbeitung von KomponentenAgenten und Werkzeuge, die Operationen mit Daten durchführen.
Schemata für die AusgabeStrukturierung und Validierung der Ergebnisse, bevor sie zurückgegeben werden.

Atomarität: funktionelle Bausteine

AtomaritätDas Konzept besteht darin, ein komplexes System in seine kleinsten funktionalen Teile oder "Atome" zu zerlegen. Jedes Atom

Eine einzige Verantwortung habenDas macht sie leichter verständlich und wartbar.
WiederverwendbarDadurch können die Komponenten in verschiedenen Teilen der Anwendung oder sogar in verschiedenen Projekten verwendet werden.
Kann mit anderen atomaren Komponenten kombiniert werden, um komplexere Funktionen aufzubauen.

Durch die Konzentration auf atomare Komponenten ermöglichen Atomic Agents eine modulare Architektur für mehr Flexibilität und Skalierbarkeit.

Die Funktionsweise atomarer Wirkstoffe

Inhaltsstoff

In Atomic Agents besteht der KI-Agent aus mehreren Schlüsselkomponenten:

SystemwarnungDefinieren Sie das Verhalten und den Zweck des Agenten.
EingabemodusStruktur: Gibt die erwartete Struktur der Eingabedaten an.
AusgabemodusStruktur der Ausgabedaten: Definiert die Struktur der Ausgabedaten.
Direktzugriffsspeicher (RAM)Speichert den Dialogverlauf oder Statusinformationen.
kontextabhängige ProgrammierungInjiziert einen dynamischen Kontext in die System-Eingabeaufforderung zur Laufzeit.
ArtefaktExterne Funktionen oder Anwendungsschnittstellen, die dem Agenten zur Verfügung stehen.

Jede Komponente ist modular aufgebaut und austauschbar und folgt den Grundsätzen der Trennung von Belangen und der Einzelverantwortung.

Modularität und Kompositionsfähigkeit

Modularität ist das Herzstück von Atomic Agents. Durch die Gestaltung von Komponenten, die in sich geschlossen sind und sich auf eine einzige Aufgabe konzentrieren, können Entwickler

Wechsel der Werkzeuge oder Mittelohne den Rest des Systems zu beeinträchtigen.
Feinabstimmung einzelner Komponentenwie z. B. Systemaufforderungen oder Modi, ohne unbeabsichtigte Nebeneffekte zu erzeugen.
Durch die Anpassung der Eingangs- und Ausgangsmodi kann dieAgenten und WerkzeugeNahtlos aneinandergereiht.

Dieser modulare Ansatz macht die Entwicklung nicht nur überschaubarer, sondern verbessert auch die Wartbarkeit und Skalierbarkeit von KI-Anwendungen.

Kontext bieten: mehr Flexibilität

kontextabhängige ProgrammierungErmöglichen Sie es Agenten, dynamische Daten in Systemabfragen einzubeziehen und Antworten auf der Grundlage der neuesten Informationen zu verbessern.

Beispiel:

from atomic_agents.lib.components.system_prompt_generator import SystemPromptContextProviderBase

class SearchResultsProvider(SystemPromptContextProviderBase): def __init__(self, title: str, search_results(self, title: str, search_results))
def __init__(self, title: str, search_results: List[str]): super().
__init__(title: str, search_results: List[str]): super(). __init__(Titel=Titel)
self.search_results = search_results
def get_info(self) -> str.
return "n".join(self.search_results)
# Registrieren des Kontextanbieters beim Agenten
agent.register_context_provider("search_results", search_results_provider)

Durch die Einbindung von Echtzeitdaten in den Kontext des Agenten können Sie dynamischere und reaktionsfähigere KI-Anwendungen erstellen.

Verkettung von Mustern und Belastungen

Atomic Agents vereinfacht den Prozess der Verkettung von Agenten und Werkzeugen durch die Anpassung der Ein- und Ausgabemodi.

Beispiel: Angenommen, Sie haben einen Agenten zur Abfragegenerierung und ein Websuchwerkzeug. Indem Sie das Ausgabemuster des Abfrageagenten so einstellen, dass es mit dem Eingabemuster des Suchwerkzeugs übereinstimmt, können Sie beide direkt miteinander verketten.

from web_search_agent.tools.searxng_search import SearxNGSearchTool

# Initialisieren des Abfrageagenten
query_agent = BaseAgent(
BaseAgentConfig(
# ... andere Konfigurationen ...
output_schema=SearxNGSearchTool.input_schema, # Ausgabeschema abgleichen
)
)

Dieses Design verbessert die Wiederverwendbarkeit und Flexibilität und ermöglicht den einfachen Austausch von Komponenten oder die Erweiterung von Funktionen.

Gründe, warum Atomic Agents besser sind als andere Produkte

Beseitigung von unnötiger Komplexität

Im Gegensatz zu Frameworks, die mehrere Abstraktionsebenen einführen, ist Atomic Agents einfach und geradlinig. Jede Komponente hat einen klaren Zweck und es gibt keine versteckte Magie, die geknackt werden muss.

transparente ArchitekturSie können vollständig nachvollziehen, wie Daten durch Ihre Anwendung fließen.
Leichtere FehlersucheIdentifizierung und Behebung von Problemen wird durch die geringere Komplexität erleichtert.
Geringere LernkurveEntwickler können schnell loslegen, ohne komplexe abstrakte Konzepte verstehen zu müssen.

Von Entwicklern für Entwickler entwickelt

Atomic Agents wurde mit Blick auf reale Entwicklungsherausforderungen konzipiert. Es verwendet bewährte und getestete Programmierparadigmen und stellt die Erfahrung der Entwickler in den Vordergrund.

Solide ProgrammierkenntnisseDurch das IPO-Modell und die Atomisierung fördert der Rahmen bewährte Praktiken.
Flexibilität und KontrolleEntwickler können die Komponenten nach Belieben anpassen und erweitern.
von der Gemeinschaft gesteuertAls Open-Source-Projekt lädt es zu Beiträgen und zur Zusammenarbeit mit der Entwicklergemeinschaft ein.

Eigenständige und wiederverwendbare Komponenten

Jeder Teil von Atomic Agents kann unabhängig laufen, was Wiederverwendbarkeit und Modularität fördert.

Kann isoliert getestet werdenKomponenten können einzeln getestet werden, um die Zuverlässigkeit vor der Integration sicherzustellen.
Projektübergreifend wiederverwendbarAtomare Komponenten können in verschiedenen Anwendungen eingesetzt werden und sparen so Entwicklungszeit.
Leichtere WartungIsolation: Die Isolationsfunktion reduziert die Auswirkungen von Änderungen und vereinfacht die Aktualisierung.

Aufbau eines einfachen AI-Agenten

Wir werden einen KI-Agenten entwickeln, der auf Benutzeranfragen antwortet und Folgefragen stellt.

Schritt 1: Definieren von benutzerdefinierten Ein- und Ausgabemodi

from pydantic import BaseModel, Field from typing import List from atomic_agents.agents.base_agent import BaseIOSchema

class BenutzerdefiniertesEingabeschema(BaseIOSchema).
chat_message: str = Field(... , description="Die Eingabenachricht des Benutzers.")

class CustomOutputSchema(BaseIOSchema): chat_message: str = Field(... , description="Die Eingaben des Benutzers.")
chat_message: str = Field(..., description="Die Eingabenachricht des Agenten.") , description="Die Antwortnachricht des Agenten.")
suggested_questions: List[str] = Field(..., description="Vorgeschlagene Fragen.") , description="Vorgeschlagene Folgefragen.")

Schritt 2: Einrichten von Systemwarnungen

from atomic_agents.lib.components.system_prompt_generator import SystemPromptGenerator

system_prompt_generator = SystemPromptGenerator(
background=[
"Sie sind ein sachkundiger Assistent, der hilfreiche Informationen liefert und Folgefragen vorschlägt."
],
background=[ "Sie sind ein sachkundiger Assistent, der hilfreiche Informationen bereitstellt und Folgefragen vorschlägt." ], steps=[
"Analysieren Sie die Eingaben des Benutzers, um den Kontext und die Absicht zu verstehen.", "Geben Sie eine relevante und informative Antwort.
"Geben Sie eine relevante und informative Antwort.", "Generieren Sie 3 vorgeschlagene Folgefragen.
"Erstelle 3 vorgeschlagene Folgefragen."
],
output_instructions=[
"Achten Sie auf Klarheit und Prägnanz in Ihrer Antwort.", "Schließen Sie mit 3 relevanten vorgeschlagenen Fragen ab.
"Schließen Sie mit 3 relevanten vorgeschlagenen Fragen ab.", "Conclude with 3 relevant suggested questions.
]
)

Schritt 3: Initialisierung des Agenten

from atomic_agents.agents.base_agent import BaseAgent, BaseAgentConfig
importieren lehrer
importieren openai

# Initialisieren des Agenten
agent = BaseAgent(
config=BaseAgentConfig(
client=instructor.from_openai(openai.OpenAI(api_key='YOUR_OPENAI_API_KEY')),
OpenAI(api_key='IHR_OPENAI_API_KEY'), model="gpt-4",

input_schema=CustomInputSchema,
output_schema=CustomOutputSchema
)
)

Schritt 4: Verwendung von Proxys

user_input = "Können Sie die Vorteile der Verwendung von Atomic Agents erklären?" input_data = CustomInputSchema(chat_message=user_input) response = agent.run( input_data)

print(f "Agent: {response.chat_message}")
print("Vorgeschlagene Fragen:")
for question in response.suggested_questions:
print(f"- {Frage}")

Erwartetes Ergebnis:

Agent: Atomic Agents vereinfacht die KI-Entwicklung durch die Bereitstellung modularer, wiederverwendbarer Komponenten, die auf soliden Programmierparadigmen wie dem IPO-Modell und Atomarität.
Vorgeschlagene Fragen.
- Wie ist Atomic Agents im Vergleich zu anderen KI-Frameworks?
- Können Sie ein Beispiel für die Entwicklung eines Agenten mit Atomic Agents geben?
- Was sind die Hauptmerkmale von Atomic Agents, die die Produktivität erhöhen?

Integrationswerkzeuge und Kontextanbieter

Angenommen, der Agent soll auf der Grundlage einer Benutzeranfrage eine Websuche durchführen.

Schritt 1: SearxNGSearchTool herunterladen und einrichten

ausnutzen Atomic Assembler CLIWir können das Suchwerkzeug herunterladen:

atomar

Wählen Sie SearxNGSearchTool aus dem Menü und folgen Sie den Anweisungen, um die Abhängigkeiten zu installieren.

Schritt 2: Integration von Suchwerkzeugen

from web_search_agent.tools.searxng_search import SearxNGSearchTool, SearxNGSearchToolConfig

# Initialisieren Sie das Suchwerkzeug
search_tool = SearxNGSearchTool(config=SearxNGSearchToolConfig(base_url="http://localhost:8080"))

Schritt 3: Aktualisieren des Agenten zur Verwendung des Tools

Wir können den Agenten so modifizieren, dass er auf der Grundlage von Benutzereingaben entscheidet, wann das Suchwerkzeug verwendet werden soll.

from typing import Union

class OrchestratorOutputSchema(BaseModel):: str = Feld(....
tool: str = Field(... , description="Das zu verwendende Tool: 'search' oder 'chat'")
parameters: Union[SearxNGSearchTool.input_schema, CustomInputSchema] = Field(... , description="Parameter für 'search' oder 'chat'") , description="Parameter für das ausgewählte Tool.")
# Ändern der Agentenlogik zur Ausgabe von OrchestratorOutputSchema
# ...
# Ausführen des ausgewählten Tools
if response.tool == "Suche".
search_results = search_tool.run(response.parameters)
# Verarbeiten Sie die Suchergebnisse
sonst.
# verwendet den vorherigen Chat-Agenten
übergeben.

Schritt 4: Verwendung eines kontextbezogenen Anbieters mit Suchergebnissen

def __init__(self, search_results): super().
        __init__(title="Search_results"). __init__(title="Suchergebnisse")
        self.search_results = search_results
def get_info(self) -> str.
return "n".join(self.search_results)
# Nach Erhalt der Suchergebnisse
context_provider = SearchResultsProvider(search_results)
agent.register_context_provider("search_results", context_provider)

Mit dieser Integration können Agenten Antworten auf der Grundlage von Websuchdaten in Echtzeit geben.

Atomic Assembler CLI: Einfache Verwaltungswerkzeuge

Ein charakteristisches Merkmal von Atomic Agents istAtomic Assembler CLIDies ist ein Befehlszeilentool, das die Verwaltung von Tools und Agenten vereinfacht.

Inspiriert von einigen modernen Tailwind-Bibliotheken wie shadcn, bei denen man die Komponenten nicht als Abhängigkeiten installiert, sondern sie in den eigenen Quellcode übernimmt.

Das bedeutet, dass wir das Tool nicht als Abhängigkeit mit pip installieren, sondern es in unser Projekt kopieren. Es gibt zwei Möglichkeiten, dies zu tun:

Laden Sie das Tool manuell herunter, oder kopieren Sie den Quellcode aus dem Atomic Agents GitHub-Repository und fügen Sie ihn in die Datei Atomschmiede Ordner.
Wir werden die Atomic Assembler CLI verwenden, um das Tool herunterzuladen.

Atomare Wirkstoffe

Schlüsselfunktion

Download- und VerwaltungstoolsEinfaches Hinzufügen neuer Werkzeuge zu Projekten ohne manuelles Kopieren oder Auflösen von Abhängigkeiten.
Vermeidung von Abhängigkeitsüberschneidungen: Halten Sie Ihr Projekt schlank, indem Sie nur die Werkzeuge installieren, die Sie benötigen.
Einfaches ÄnderungswerkzeugJedes Tool ist unabhängig und verfügt über eigene Tests und eine eigene Dokumentation.
Werkzeuge für den direkten ZugangWenn Sie möchten, können Sie die Werkzeuge manuell verwalten, indem Sie auf den Ordner Werkzeuge zugreifen.

am Ende schreiben

Atomic Agents bringt eine dringend benötigte Veränderung im Bereich der KI-Entwicklung, indem es Einfachheit, Modularität und Kontrolle durch den Entwickler in den Vordergrund stellt. Durch die Übernahme zuverlässiger Programmierparadigmen wie dem Input-Process-Output-Modell und Atomarität löst es viele der Probleme, mit denen Entwickler bei der Verwendung von LangChain, CrewAI und AutoGen Die Frustrationen, die in bestehenden Rahmenwerken wie dem

Mit Atomic Agents können Sie

Beseitigung von unnötiger Komplexitätdas sich auf die Entwicklung effektiver KI-Anwendungen konzentriert.
Vollständige Kontrollejede Komponente des Systems.
Einfacher Austausch oder Änderung von Komponentenohne die gesamte Anwendung zu unterbrechen.
Nutzung von Modularität und WiederverwendbarkeitVerbesserung der Effizienz und Wartungsfreundlichkeit.

Wenn Sie es leid sind, sich mit übermäßig komplexen Frameworks herumzuschlagen, die zu viel versprechen und zu wenig halten, ist es an der Zeit, Atomic Agents auszuprobieren.