# Einführung

Vor 18 Monaten bedeutete die Verbindung eines KI-Agenten mit einem externen Device, für jede Integration maßgeschneiderten Glue-Code zu schreiben. Dann stellte Anthropic Ende 2024 das Mannequin Context Protocol (MCP) als Open-Supply-Lösung zur Verfügung, OpenAI, Google und Microsoft übernahmen es bis 2025, und das Protokoll wurde veröffentlicht an eine Organisation der Linux Basis gespendet am Ende des Jahres. MCP wurde zum USB-C der Agenten-Instruments: ein Commonplace, und plötzlich lässt sich jedes kompatible Device an jeden konformen Agenten anschließen.

Der Haken an der Sache ist, dass das Ökosystem explodiert ist, das meiste davon Lärm ist und – seltsamerweise – mehrere Server, die ältere Listicles noch empfehlen, inzwischen archiviert wurden. Hier sind fünf, die es wirklich wert sind, in ein leistungsstarkes Agentenentwicklungs-Setup integriert zu werden. Sie werden aufgrund ihrer Auswirkung auf die tatsächliche Leistungsfähigkeit eines Agenten und nicht aufgrund seiner Anzahl an Sternen ausgewählt. (Diese unten aufgeführten Sterne waren zum Zeitpunkt des Schreibens aktuell und bewegen sich schnell.)

# 1. GitHub MCP-Server

Der offizieller GitHub MCP-Server ist das Rückgrat jedes Agenten, der Ihren Entwicklungsworkflow berührt. Es stellt einem Agenten Repositorys, Probleme, Pull-Requests, Aktionen und Codesicherheit über natürliche Sprache zur Verfügung, und da GitHub diese verwaltet, verfolgt es die Plattform, anstatt hinter ihr zurückzubleiben.

Speziell für die Agentenentwicklung besteht der Unterschied zwischen einem Agenten, der über Code nachdenken kann, und einem Agenten, der ihn tatsächlich verschieben kann: eine Pull-Anfrage öffnen, ein Drawback selektieren, einen fehlgeschlagenen Workflow überprüfen. Rund 30.000 Sterne, aktiv gepflegt, und den auf dieser Liste erreichen Sie als Erstes.

# 2. Dramatiker MCP (Microsoft)

Bei der Browser-Automatisierung sterben viele Agenten, meist weil sie versuchen, Screenshots mit einem Imaginative and prescient-Modell zu interpretieren und Pixelkoordinaten zu erraten. Microsofts Dramatiker MCP umgeht dies vollständig, indem es den Browser durch den Barrierefreiheitsbaum steuert und dem Agenten strukturierte, deterministische Daten über die Seite liefert, anstatt ein Bild, auf das er blinzeln kann.

Das Ergebnis ist eine schnellere und zuverlässigere Webinteraktion über die über 40 Instruments hinweg und kein Visionsmodell in der Schleife. Für jeden Agenten, der eine Webanwendung testen, eine gerenderte Seite scannen oder einen Circulate abschließen muss, ist dies die leistungsorientierte Wahl. Ungefähr 31.000 Sterne und regelmäßige Versandaktualisierungen.

# 3. Kontext7 (Upstash)

Dies ist diejenige, die die Qualität des generierten Codes am direktesten verbessert. Kontext7 fügt aktuelle, versionenspezifische Bibliotheksdokumentation direkt in den Kontext des Agenten ein, der den häufigsten Fehler in der KI-Codierung angreift: die selbstbewusst halluzinierte API, die vor zwei Versionen veraltet conflict oder nie existierte.

Wenn Ihr Agent Code für sich schnell bewegende Bibliotheken schreibt, ist dies der Server mit der höchsten Hebelwirkung auf der Liste, und seine Beliebtheit spiegelt dies wider – er liegt bei quick 59.000 Sternen und weist eine sehr aktive Entwicklung auf. Von diesen fünf ist es derjenige, der jedem codegenerierenden Agenten zuerst hinzugefügt werden sollte, da er Fehler behebt, bevor sie geschrieben werden, und sie nicht erst danach abfängt.

# 4. Serena (Oraios)

Das Suchen und Ersetzen von Textual content ist eine einfache Möglichkeit für einen Agenten, Code zu bearbeiten, und dabei werden viele Token ausgegeben und viele Fehler gemacht. Serena Vermittelt einem Agenten über das Language Server Protocol (LSP) ein semantisches Verständnis einer Codebasis auf Symbolebene in mehr als 40 Sprachen, sodass er die tatsächliche Funktion oder das tatsächliche Image finden und bearbeiten kann, anstatt Muster auf Zeichenfolgen abzugleichen.

Der praktische Vorteil liegt in der Präzision und Token-Effizienz: Der Agent liest und ändert genau das, was er benötigt, was bei großen Codebasen, bei denen das Ablegen ganzer Dateien in den Kontext sowohl langsam als auch teuer ist, von enormer Bedeutung ist. Stellen Sie sich das so vor, als würden Sie Ihrem Codierungsagenten das Verständnis einer IDE statt des eines Texteditors geben. Rund 24.000 Sterne.

# 5. Die offiziellen Referenzserver

Abgerundet wird ein seriöses Setup offizielle Referenzserversammlung liefert die zuverlässigen Grundelemente: Dateisystem für lokalen Dateizugriff, Git, Fetch, Speicher und sequentielles Denken, das einem Agenten einen strukturierten Raum gibt, um Schritt für Schritt zu überlegen, bevor er handelt. Das Monorepo verfügt insgesamt über weit über 80.000 Sterne, obwohl diese Zahl eher das gesamte Set als einen einzelnen Server abdeckt.

Zwei ehrliche Vorbehalte. Diese werden als pädagogische Referenzen gepflegt, additionally behandeln Sie sie als solide Bausteine ​​und nicht als gehärtete Produktionsinfrastruktur. Und beachten Sie, dass das Projekt mehrere einst beliebte Server archivierte – darunter die eigenständigen Postgres- und Puppeteer-Server –, was genau der Grund ist, warum so viele ältere „Prime-MCP-Server“-Beiträge jetzt auf tote Repositories verweisen. Überprüfen Sie, ob ein Server aktiv ist, bevor Sie darauf aufbauen.

# Aufbau des Stapels

Wenn Sie diese miteinander verbinden, haben Sie einem Agenten kohärente Hände an die Hand gegeben: GitHub zum Verschieben von Code, Playwright zum Betreiben des Webs, Context7 zum Schreiben korrekten Codes, Serena zum präzisen Bearbeiten und die Referenzserver für die lokale Set up. Das Protokoll hat den schwierigen Teil geleistet, indem es sie interoperabel gemacht hat. Ihre Aufgabe besteht nun darin, eine gute Auswahl zu treffen und Server auszuwählen, die noch vorhanden sind.

Nahla Davies ist Softwareentwickler und technischer Autor. Bevor sie sich hauptberuflich dem technischen Schreiben widmete, schaffte sie es – neben anderen faszinierenden Dingen –, als leitende Programmiererin bei einer Inc. 5.000-Organisation für experimentelles Branding zu arbeiten, zu deren Kunden Samsung, Time Warner, Netflix und Sony gehören.

ist ein Konzept, bei dem Sie viele Informationen speichern und sie für die zukünftige Verwendung zugänglich machen. Das ist unglaublich wirkungsvoll für:

• Bessere Entscheidungsfindung
• Schnelles Aufgreifen vergangener Zusammenhänge
• Ausrichtung Ihres Groups

In letzter Zeit habe ich viel damit begonnen, eine Wissensdatenbank einzurichten und so viel Kontext wie möglich hineinzuleiten, um alle oben genannten Punkte zu verbessern. Wissensdatenbanken waren schon vor LLMs immer nützlich, da es immer nützlich ist, auf früheres Wissen zuzugreifen. Allerdings sind die Wissensdatenbanken durch LLMs exponentiell leistungsfähiger geworden.

Dies hat zwei Hauptgründe:

• Weitere Informationen können Sie in den Wissensdatenbanken erfassen
• Sie können die Wissensdatenbank einfacher abfragen (Sie müssen sie nicht manuell durchsuchen).

In diesem Artikel erkläre ich, warum Sie Ihre eigene LLM-gestützte Wissensdatenbank einrichten sollten, wie Sie so viele Informationen wie möglich erfassen und wie Sie die Wissensdatenbank aktiv nutzen.

Ich habe dieses Thema schon einmal diskutiert, aber das Thema Wissensdatenbanken gefällt mir immer mehr, weil es so beliebt ist. Sie haben zum Beispiel den Präsidenten des Y-Combinator-Gebäudes GBrainoder Andrej Karpathy baut ein LLM-Wiki aufbeides Beispiele für Wissensdatenbanken.

Es gibt natürlich keine fundierte Aussage darüber, wie eine Wissensbasis optimum aufgebaut werden kann. Ich denke, das Wichtigste ist, tatsächlich damit zu beginnen, den gesamten Kontext in einer Wissensdatenbank zu speichern und herauszufinden, wie man die Wissensdatenbank jederzeit effektiv abfragen kann, zum Beispiel beim Schreiben von Code, in Besprechungen oder ähnlichem.

Warum Sie eine Wissensdatenbank haben sollten

Zunächst möchte ich erläutern, warum Sie über eine Wissensdatenbank verfügen sollten. Sie können über unterschiedliche Wissensdatenbanken verfügen. Sie können beispielsweise eine persönliche Wissensdatenbank haben, die aus dem gesamten Kontext besteht, über den Sie persönlich verfügen, oder Sie können eine unternehmensweite Wissensdatenbank haben, die aus Wissen oder Kontexten besteht, über die das Unternehmen verfügt.

Der Grund, warum Sie über eine Wissensdatenbank verfügen sollten, liegt darin, dass Informationen äußerst wertvoll sind. Je mehr Informationen Sie speichern und später bei Bedarf abrufen können, desto besser ist Ihre Leistung. Sie können zum Beispiel:

• Treffen Sie bessere Entscheidungen, weil Sie Zugriff auf mehr Kontext haben
• Erfassen Sie frühere Themen schneller, ohne verschiedene Quellen durchsuchen zu müssen, um die Informationen zu dem Thema zu finden
• Bringen Sie verschiedene Menschen zusammen, weil sie eine einzige Quelle der Wahrheit haben.

Die gleichen Konzepte gelten grundsätzlich sowohl für den Fall, dass Sie über eine persönliche Wissensdatenbank verfügen, als auch für den Fall, dass Sie über eine unternehmensweite Wissensdatenbank verfügen. Ich glaube auch, dass diese Wissensdatenbanken viel leistungsfähiger geworden sind, weil man sie mit LLMs abfragen kann. Bisher mussten Sie die Wissensdatenbank manuell durchsuchen, um relevante Informationen zu finden. Sie müssten Ihr eigenes Gedächtnis nutzen, um sich daran zu erinnern, ob eine bestimmte Info in der Wissensdatenbank gespeichert warfare, und dann entscheiden, ob Sie Zeit damit verbringen möchten, diese Informationen zu finden oder nicht.

Das hat sich nun völlig umgedreht. Das LLM kann die Wissensdatenbank beispielsweise mit einem RAG-Ansatz selbst abfragen und relevante Informationen sofort automatisch finden. Der LLM kann selbst entscheiden, wann er die Wissensbasis nutzen muss.

Das heißt, Sie entfernen vollständig die Ebene, die Human-in-the-Loop-Anforderung für den Zugriff auf Informationen in einer Wissensdatenbank, was diese wesentlich leistungsfähiger macht.

Erfassen von Informationen in der Wissensdatenbank

Der erste Schritt der Wissensdatenbank besteht natürlich darin, Informationen in der Wissensdatenbank zu erfassen. Je nachdem, wie Ihre Wissensbasis aufgebaut ist, kann dies auf unterschiedliche Weise geschehen.

Als Erstes möchte ich Sie jedoch bitten, an all die verschiedenen Informationsquellen zu denken, auf die Sie persönlich oder im Unternehmen Zugriff haben. Dies sind zum Beispiel:

• Treffen
• Ihr Projektmanagement-Software, z. B. Linear.
• Ihr Codierungsagent, z. B. Claude Code oder Codex. Woran haben Sie in letzter Zeit mit diesen Modellen gearbeitet (und welche Aufgaben wurden erledigt)?
• Besprechungen im Büro.

Ihnen fallen wahrscheinlich viele verschiedene andere Informationsquellen ein. Das hängt natürlich ein bisschen davon ab, wie man arbeitet und wo man arbeitet. Der Punkt ist, dass Sie all diese verschiedenen Informationsquellen abbilden und einen automatischen Weg finden sollten, Informationen aus diesen Quellen in Ihre Wissensdatenbank weiterzuleiten.

Sie und andere werden nicht bereit sein, mehr Zeit damit zu verbringen, Dinge manuell in Wissensdatenbanken einzupflegen. Sie müssen einen Weg finden, dies automatisch zu tun, um Ihre Wissensdatenbank auf dem neuesten Stand zu halten.

Es ist wichtig, dass Sie die Weiterleitung der Informationen von der Quelle zur Wissensdatenbank vollständig automatisieren. Wenn Sie einen manuellen Schritt benötigen (z. B. das Einfügen von Besprechungsnotizen in die Wissensdatenbank), werden Sie ihn mit Sicherheit vergessen und wichtigen Kontext verlieren, was dem gesamten Konzept der Wissensdatenbank zuwiderläuft. Der Sinn der Wissensdatenbank besteht darin, dass Sie dort absolut alle Informationen speichern und nichts auslassen. Das macht eine Wissensdatenbank so leistungsstark.

Beispielsweise können Sie für Besprechungsnotizen einen Cronjob einrichten, der täglich synchronisiert wird. Es nimmt jede Besprechungsnotiz auf, die jeder im Unternehmen oder Sie persönlich hatte, und speichert sie in einer Wissensdatenbank. Sie können einen ähnlichen Cron-Job für Ihr Linear- oder Projektmanagement-Software einrichten, um alles zu synchronisieren, was dort passiert ist. Synchronisieren Sie Ihren Codierungsagenten mit dem, woran Sie gearbeitet haben, mit allem, was Sie mit Ihrem Codierungsagenten besprochen haben usw. All dies kann einfach mit einem täglichen Cronjob in die Wissensdatenbank synchronisiert werden.

Besprechungen im Büro sind ein Punkt, der sich schwerer vollständig automatisieren lässt. Ich habe das selbst noch nicht ganz herausgefunden, aber zwei Möglichkeiten wären:

1. ständig alles aufzuzeichnen, was vor sich geht, wofür natürlich eine Einwilligung erforderlich wäre
2. oder einfach manuell Dinge aufschreiben, nachdem man im Büro eine Diskussion geführt hat

Ich denke jedoch, dass Sie die Bürodiskussionen möglicherweise nicht einmal explizit speichern müssen, da in den meisten Fällen, nachdem ich eine Diskussion physisch im Büro geführt habe, die Particular person, mit der ich die Diskussion geführt habe, oder ich den Kontext aus dieser Diskussion nehmen und ihn in ihren Codierungsagenten schreiben. Diese Diskussion wurde normalerweise aufgrund einer Frage zu einer Implementierung geführt. Wenn dieses Wissen additionally anschließend aktiv in Ihrem Codierungsagenten verwendet wird, können Sie es aus den Protokollen des Codierungsagenten abrufen.

Wenn Sie diesen Schritt additionally erfolgreich abgeschlossen und den gesamten Kontext, auf den Sie täglich stoßen, in Ihrer Wissensdatenbank gespeichert haben, haben Sie den größten Teil der Arbeit erledigt. Das ist der schwierige Teil der Wissensdatenbank. Im nächsten Abschnitt werde ich den einfacheren Teil behandeln, bei dem die Informationen aus der Wissensdatenbank aktiv genutzt werden, wenn Entscheidungen getroffen werden oder mit Ihren Programmieragenten interagiert wird.

Nutzung von Informationen aus der Wissensdatenbank

Wenn Sie über eine synchronisierte Wissensdatenbank mit allen benötigten Informationen verfügen, können Sie diese Informationen nun aktiv nutzen. Ich denke, es gibt zwei Hauptansätze zur Nutzung der Informationen aus einer Wissensdatenbank:

1. Wenn Sie eine Frage haben, können Sie einfach die Wissensdatenbank abfragen. Dies sollte natürlich über Ihren Codierungsagenten erfolgen. Sie stellen ihm eine Frage und er sollte wissen, dass er die Wissensdatenbank abfragen muss, um die Antwort zu finden.
2. Die zweite besteht darin, dass der Codierungsagent die Wissensdatenbank passiv nutzt, wann immer sie funktioniert.

Ich denke, die erste Anwendung hier ist ziemlich selbsterklärend. Stellen Sie die Frage einfach immer dann, wenn Sie sich bei etwas nicht sicher sind. Deshalb werde ich hier mehr Zeit auf die Diskussion des zweiten Punktes verwenden.

Wenn der Codierungsagent die Wissensdatenbank bei jeder Arbeit passiv nutzt, beispielsweise um eine Codeimplementierung durchzuführen, einen Fehler zu beheben usw. Das ist sehr leistungsstark. Auch hier denke ich, dass es hierfür zwei Hauptansätze gibt.

Grep-basierte Schlussfolgerung

Eine besteht darin, eine Markdown-Datei auf oberster Ebene in der Wissensdatenbank zu haben, die die gesamte Wissensdatenbank erklärt und erklärt, wo sich die verschiedenen Informationen befinden. Diese Datei wird natürlich immer dann aktualisiert, wenn Sie der Wissensdatenbank weitere Informationen hinzufügen.

Der Vorteil dieses Ansatzes besteht darin, dass Sie grep verwenden, das normalerweise leistungsfähiger ist als die einbettungsbasierte Suche, da es bei Bedarf besser die richtigen Informationen finden kann. Dies erfordert jedoch auch, dass Sie diese Markdown-Datei in den Kontext des LLM einfügen, das Sie ständig verwenden. Diese Markdown-Datei kann sehr groß werden, was nach einiger Zeit zu einem Downside werden kann.

Einbettungsbasierte Inferenz

Die zweite Möglichkeit, die Wissensdatenbank aktiv zu nutzen, besteht in einer einbettungsbasierten Inferenz. Dafür ist GBrain gemacht. Wenn Sie eine Abfrage ausführen, führen Sie grundsätzlich eine eingebettete Suche durch, etwa eine RAG in der Wissensdatenbank, und diese ruft einige relevante Abschnitte aus der Wissensdatenbank ab. Wenn der LLM denkt, dass er mithilfe der Einbettungssuche relevante Informationen abgerufen hat, kann er die relevanten Dateien weiter untersuchen.

Ich denke, dass dies wahrscheinlich der bessere Ansatz für die Verwendung der Wissensdatenbank während der Inferenz ist, da keine aktive Suche erforderlich ist und nicht für alles, was Sie tun, viele Eingabetokens für die Wissensdatenbank ausgegeben werden müssen.

Welcher Ansatz am besten funktioniert, hängt jedoch definitiv von Ihren Anwendungsfällen ab.

Abschluss

Alles in allem fordere ich Sie auf:

1. Versuchen Sie, eine Wissensdatenbank einzurichten
2. Schreiben Sie so viele Informationen wie möglich hinein
3. Lesen Sie, wie andere diese Wissensdatenbanken eingerichtet haben
4. Versuchen Sie es selbst einzurichten

Dann sollten Sie diese Wissensdatenbank immer dann aktiv nutzen, wenn Sie mit einem Codierungsagenten an Ihrem Pc arbeiten (was grundsätzlich für alle Arbeiten gelten sollte, die Sie durchführen). Ich glaube, dass Wissensdatenbanken in den kommenden Jahren unglaublich leistungsfähig und wertvoll sein werden, und sie können Ihnen auch einen Vorsprung verschaffen, da der Zugriff auf viele Informationen in Zukunft ein klarer Vorteil sein wird. Darüber hinaus handelt es sich hierbei um spezifische Daten zu Ihrem Unternehmen oder Ihrem persönlichen Kontext, auf die in vielen Fällen nur Sie Zugriff haben. Wenn Sie sie additionally nicht speichern, können Sie in Zukunft nie wieder auf diese Informationen zugreifen.

Nehmen Sie Kontakt auf

Mein kostenloses E-E-book und Webinar:

Verzehnfachen Sie Ihr Engineering mit LLMs (kostenloser 3-tägiger E-Mail-Kurs)

Holen Sie sich mein kostenloses E-E-book „Imaginative and prescient Language Fashions“.

Mein Webinar zu Imaginative and prescient Language Fashions

Finden Sie mich in den sozialen Netzwerken:

Unterstapel

LinkedIn

X / Twitter

ein in letzter Zeit sehr beliebtes Thema bei Programmieragenten. Schleifen sind im Grunde ein Konzept, bei dem ein Agent in einer selbstverifizierenden Schleife arbeitet und der Agent autonomer arbeitet.

Dies steht im Gegensatz zu der Artwork und Weise, wie wir zuvor Codierungsagenten verwendet haben, wo Sie einen neuen Codierungsagenten starten, den Codierungsagenten dazu veranlassen, etwas zu implementieren, seine Ergebnisse überprüfen und so weitermachen, bis Sie mit Ihrer Arbeit fertig sind.

Schleifen sind unglaublich leistungsfähig, weil sie es Ihnen ermöglichen, als Mensch mehr in den Hintergrund zu treten und mehr Aufgaben zu erledigen. Dies liegt daran, dass Sie den Agenten nicht so genau überwachen müssen, er selbstständiger arbeitet und die Arbeit besser durchgängig erledigen kann.

In diesem Artikel erörtere ich, warum Sie bei der Interaktion mit Codierungsagenten in Schleifen arbeiten sollten und wie Sie dies tun können. Ich werde einige Techniken behandeln, die Sie bei der Interaktion mit Codierungsagenten aktiv nutzen sollten, um effektiv Schleifen einzurichten und Ihre Codierungsagenten so effektiv wie möglich zu machen.

Warum Schleifen mit Codierungsagenten verwenden?

Lassen Sie uns zunächst erläutern, warum Sie bei der Verwendung von Codierungsagenten Schleifen verwenden sollten. Die einfachste Antwort ist, dass Schleifen es Ihnen ermöglichen, mehr Arbeit zu erledigen.

Der Grund dafür ist, dass der Agent beim Einrichten einer Schleife Aufgaben besser autonom Ende-zu-Ende erledigen kann, wodurch Sie als Mensch mehr Zeit gewinnen und mehr Arbeit erledigen können.

Sie können sich diese beiden Szenarien vorstellen:

Szenario 1: Sie starten Agent A, erstellen einen Plan damit und lassen ihn mit der Arbeit beginnen. Anschließend starten Sie Agent B, und bevor Sie mit der Planung der Aufgabe mit Agent B fertig sind, stellt Agent A Ihnen Fragen oder teilt Ihnen mit, dass einige Arbeiten abgeschlossen sind und Sie diese überprüfen müssen. Sie beschließen, Agent B fertigzustellen, und gleich nachdem Sie dort fertig sind, kehren Sie zu Agent A zurück. Interagieren Sie mit ihm, sorgen Sie dafür, dass er weiter funktioniert, und bevor Sie dort fertig sind, benötigt Agent B erneut Eingaben von Ihnen. Dann machen Sie so weiter und können nur mit zwei Agenten gleichzeitig interagieren, additionally im Wesentlichen zwei Aufgaben gleichzeitig erledigen.

Szenario 2: Sie starten Agent A und lassen ihn eine Schleife ausführen, um seine Arbeit selbst zu überprüfen. Agent A beginnt dann mit der Arbeit an einer Aufgabe und Sie teilen ihm mit, dass er sich erst wieder bei Ihnen melden soll, wenn die Aufgabe erledigt ist. Sobald Sie die Anweisungen für Agent A abgeschlossen haben, können Sie dasselbe für Agent B tun, indem Sie ein Ziel festlegen und es in einer Schleife arbeiten lassen. Diesmal unterbricht Agent A Sie nicht für weitere Eingaben, da er über die Selbstverifizierungsschleife verfügt und Ihre Eingaben nicht mehr auf die gleiche Weise benötigt. Somit können Sie den Agenten C, D, E usw. weiterhin Aufgaben zuweisen, bis Agent A seine Arbeit beendet hat.

Die Schlussfolgerung hier ist, dass Sie in Szenario 2 einfach mehr Agenten einsetzen und mehr Aufgaben erledigen können, was natürlich unglaublich wertvoll ist, da Sie dadurch mehr Arbeit auf einmal erledigen können.

Wie man in Schleifen arbeitet

Die große Frage ist nun natürlich: Wie arbeitet man eigentlich in Schleifen? Es gibt viele verschiedene Möglichkeiten, aber ich werde die einfachste Technik behandeln, mit deren Umsetzung Sie sofort beginnen können.

Bei dieser Technik wird der Befehl /aim entweder mit Claude Code oder Codex verwendet.

/aim <outline your aim right here and  confirm it>

Ich sage zum Beispiel:

/aim Implement every thing I requested for. Confirm it finish to finish by clicking 
via the browser utilizing the Playwright MCP. It is not acceptable to check 
the applying solely via integration checks. It's essential to really click on 
across the app. Proceed like this till it really works. Repair any points in case you 
encounter them then do an finish to finish take a look at once more. Run Codex exec and run
the evaluation ability with Codex and make him approve it and iterate till 
Codex has accredited it. When Codex has accredited it, come to me and inform 
me which servers I can take a look at it on and precisely  take a look at it.

Im Wesentlichen implementiert /aim einen Hook. Dieser Hook wird jedes Mal ausgelöst, wenn Claude Code oder Codex seine Arbeit beendet, und veranlasst den Codierungsagenten grundsätzlich darüber nachzudenken, ob er die von Ihnen unter /aim geschriebene Aufgabe abgeschlossen hat oder nicht. Wenn es fertig ist, kommt es zu Ihnen zurück und informiert Sie über seine Arbeit. Wenn es denkt, dass es noch nicht abgeschlossen ist, wird es weiter auf dieses Ziel hinarbeiten, bis es zufrieden ist.

Es handelt sich im Wesentlichen um eine Möglichkeit, die Programmieragenten so lange weiterarbeiten zu lassen, bis sie Ihr Ziel tatsächlich erreichen oder glauben, dass es völlig unerreichbar ist. Eine sehr leistungsstarke Möglichkeit, Codierungsagenten über einen längeren Zeitraum arbeiten zu lassen und so autonomer zu arbeiten und mehr Arbeit zu erledigen.

Beachten Sie außerdem, dass ich dem Agenten in der Eingabeaufforderung viele weitere Informationen gebe, wie er seine Arbeit überprüfen kann. Dies ist ein Thema, das ich im nächsten Abschnitt behandeln werde, da es unglaublich wichtig ist, wenn Sie den Befehl /aim optimum nutzen möchten.

Wie man /aim effektiv macht

In diesem Abschnitt beschreibe ich, wie der Befehl /aim wirksam wird. Natürlich können Sie dem Agenten einfach ein Ziel vorgeben, aber wenn Sie nicht genau wissen, welches Ziel Sie setzen und wie der Agent das Ziel überprüfen kann, werden Sie keine guten Ergebnisse erzielen.

Sie müssen dem Agenten eine Möglichkeit bieten, seine eigene Arbeit zu überprüfen und das Risiko von Fehlern zu minimieren. Ich mache das im Wesentlichen auf zwei Arten:

1. Weisen Sie den Agenten an, seine Arbeit durchgängig mithilfe des Playwright MCP und der Interaktion mit dem Browser zu überprüfen
2. Lassen Sie den Agenten Codex Exec ausführen, um den bereitgestellten Code zu überprüfen und das Risiko von Fehlern zu minimieren

Ich gehe auf den ersten Punkt ein: Ich habe Playwright MCP verwendet, aber Sie können jede gewünschte Browser-Interaktionsmethode verwenden. Ich magazine Playwright, weil es sehr intestine funktioniert und der Agent in der Lage ist, alle seine Arbeiten zu erledigen. Dem Agenten mitzuteilen, dass er seine Arbeit durchgängig überprüfen soll, ist sehr effektiv, da der Agent in den Browser oder in meine App geht, Screenshots macht und überprüft, ob alles wie vorgesehen funktioniert. Dies ist eine unglaublich wirkungsvolle und wirklich einfache Änderung, die Sie vornehmen können, um die Effektivität Ihrer Codierungsagenten mindestens zu verdoppeln.

Wenn Sie nicht mit einer Benutzeroberfläche arbeiten, können Sie den Agenten natürlich anweisen, einfach API-Aufrufe durchzuführen und die Datenbanken oder Protokolle zu überprüfen, um sicherzustellen, dass alles wie erwartet funktioniert. Der springende Punkt ist, dass Sie den Codierungsagenten nicht nur dazu bringen, seine Arbeit zu überprüfen, indem er sich den Code ansieht. Sie sorgen dafür, dass der Code tatsächlich ausgeführt wird, und lassen Sie die Ausgaben und Ergebnisse des Codes überprüfen.

Zweitens verwende ich normalerweise Claude Code als meinen Haupttreiber bei der Entwicklung von Code, aber ich habe herausgefunden, dass man mit Codex immer noch viel Nutzen daraus ziehen kann.

Ich verwende Codex, um meinen Agenten, meinen Claude Code-Agenten, Bewertungen bereitzustellen. Wann immer sie Code veröffentlichen oder Code veröffentlichen und Code in die Entwicklung übernehmen möchten, veranlasse ich Codex, den Code zu überprüfen und zu genehmigen, bevor Claude ihn in die Entwicklung einbinden darf. Das hat mir so viele Fehler erspart, dass es kaum zu verstehen ist.

Es gibt auch einen großen Unterschied in meiner Erfahrung zwischen der Überprüfung des Codes durch Claude Code und Codex. Wenn ich Claude Code als Haupttreiber zum Implementieren von Code verwende, möchte ich auf jeden Fall Codex verwenden, um den Code anschließend zu überprüfen, und nicht Claude Code. Das liegt daran, dass Codex einfach in der Lage ist, mehr Fehler zu finden. Ich erstelle ein iteratives Setup, bei dem Claude Code den Code implementiert, ihn durch Codex überprüfen lässt, die Überprüfungskommentare korrigiert und Codex zur erneuten Überprüfung markiert. Wir machen so weiter, bis Codex den Code genehmigt hat.

Dadurch wird die Anzahl der Fehler, die Sie durch Claude Code erfahren, drastisch reduziert.

Abschluss

In diesem Artikel habe ich besprochen, wie man Schleifen in Claude Code einrichtet. Schleifen als Konzept sind in letzter Zeit sehr in Mode gekommen, da sie den Programmieragenten eine Möglichkeit bieten, autonomer zu arbeiten und mehr Arbeit zu erledigen. Mit dem /goal-Befehl können Sie ganz einfach Schleifen einrichten, die den Agenten so lange auf ein Ziel hinarbeiten, bis es erreicht ist. Sie müssen dem Agenten jedoch auch die Möglichkeit geben, seine eigene Arbeit zu überprüfen, was ich ebenfalls in diesem Artikel behandelt habe. Ich glaube, dass die Zukunft des Software program-Engineerings in der Schaffung solcher Schleifen liegt. Sie erstellen Agenten, die in Schleifen arbeiten, und geben ihnen die Möglichkeit, ihre eigene Arbeit zu überprüfen. Dadurch haben Sie die Möglichkeit, mehrere Aufgaben gleichzeitig zu bearbeiten. Schleifen als Konzept können auch um größere Schleifen erweitert werden, die andere kleinere Schleifen organisieren, sowie um sich selbst verbessernde Schleifen. Dies sind weitere Konzepte, die ich in zukünftigen Artikeln behandeln werde.

Nehmen Sie Kontakt auf

Mein kostenloses E-Ebook und Webinar:

Verzehnfachen Sie Ihr Engineering mit LLMs (kostenloser 3-tägiger E-Mail-Kurs)

Holen Sie sich mein kostenloses E-Ebook „Imaginative and prescient Language Fashions“.

Mein Webinar zu Imaginative and prescient Language Fashions

Finden Sie mich in den sozialen Netzwerken:

Unterstapel

LinkedIn

X / Twitter

Bild vom Herausgeber

# Einführung

Python-Dekoratoren kann bei Projekten, an denen beteiligt ist, unglaublich nützlich sein Entwicklung von KI- und maschinellen Lernsystemen. Sie zeichnen sich dadurch aus, dass sie wichtige Logik wie Modellierung und Datenpipelines von anderen Standardaufgaben wie Checks und Validierung, Timing, Protokollierung usw. trennen.

In diesem Artikel werden fünf besonders nützliche Python-Dekoratoren vorgestellt, die sich auf der Grundlage der Erfahrung von Entwicklern als wirksam erwiesen haben, wenn es darum geht, KI-Code sauberer zu machen.

Die folgenden Codebeispiele umfassen einfache, zugrunde liegende Logik, die auf Python-Standardbibliotheken und Finest Practices basiert, z functools.wraps. Ihr Hauptziel besteht darin, die Verwendung jedes einzelnen Dekorators zu veranschaulichen, sodass Sie sich nur um die Anpassung der Logik des Dekorators an Ihr KI-Codierungsprojekt kümmern müssen.

# 1. Parallelitätsbegrenzer

Ein sehr nützlicher Dekorator, wenn es um (oft ärgerliche) Free-Tier-Beschränkungen bei der Verwendung von Giant Language Fashions (LLMs) von Drittanbietern geht. Wenn aufgrund des Sendens zu vieler asynchroner Anforderungen solche Grenzwerte erreicht werden, führt dieses Muster einen Drosselungsmechanismus ein, um diese Aufrufe sicherer zu machen. Durch Semaphoren wird die Anzahl der Ausführungen einer asynchronen Funktion begrenzt:

import asyncio
from functools import wraps

def limit_concurrency(restrict=5):
    sem = asyncio.Semaphore(restrict)
    def decorator(func):
        @wraps(func)
        async def wrapper(*args, **kwargs):
            async with sem:
                return await func(*args, **kwargs)
        return wrapper
    return decorator

# Utility
@limit_concurrency(5)
async def fetch_llm_batch(immediate):
    return await async_api_client.generate(immediate)

# 2. Strukturierter Machine-Studying-Logger

Es ist keine Überraschung, dass in komplexer Software program wie der, die maschinelle Lernsysteme regelt, Normal print() Anweisungen gehen leicht verloren, insbesondere wenn sie in der Produktion eingesetzt werden.

Mit dem folgenden Protokollierungsdekorator ist es möglich, Ausführungen und Fehler zu „fangen“ und sie in strukturierte JSON-Protokolle zu formatieren, die für ein schnelles Debugging leicht durchsuchbar sind. Das folgende Codebeispiel kann als Vorlage verwendet werden, um beispielsweise eine Funktion zu dekorieren, die eine Trainingsepoche in einem auf einem neuronalen Netzwerk basierenden Modell definiert:

import logging, json, time
from functools import wraps

def json_log(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        begin = time.time()
        attempt:
            res = func(*args, **kwargs)
            logging.information(json.dumps({"step": func.__name__, "standing": "success", "time": time.time() - begin}))
            return res
        besides Exception as e:
            logging.error(json.dumps({"step": func.__name__, "error": str(e)}))
            increase
    return wrapper

# Utility
@json_log
def train_epoch(mannequin, training_data):
    return mannequin.match(training_data)

# 3. Characteristic-Injektor

Geben Sie während der Modellbereitstellungs- und Inferenzphase einen besonders nützlichen Dekorateur ein! Angenommen, Sie verschieben Ihr maschinelles Lernmodell von einem Pocket book in eine einfache Produktionsumgebung, z. B. mithilfe von a FastAPI Endpunkt. Die manuelle Sicherstellung, dass eingehende Rohdaten von Endbenutzern denselben Transformationen unterliegen wie die ursprünglichen Trainingsdaten, kann manchmal etwas mühsam sein. Der Characteristic-Injektor sorgt dafür, dass die Artwork und Weise, wie Options aus Rohdaten generiert werden, unter der Haube konsistent bleibt.

Dies ist während der Bereitstellungs- und Inferenzphase äußerst nützlich. Beim Verschieben eines Modells von einem Jupyter-Pocket book in eine Produktionsumgebung besteht ein großes Downside darin, sicherzustellen, dass die rohen eingehenden Benutzerdaten dieselben Transformationen erhalten wie Ihre Trainingsdaten. Dieser Dekorator stellt sicher, dass diese Funktionen unter der Haube konsistent generiert werden, bevor die Daten jemals Ihr Modell erreichen.

Das folgende Beispiel vereinfacht das Hinzufügen einer Funktion namens 'is_weekend'basierend darauf, ob eine Datumsspalte in einem vorhandenen Datenrahmen ein Datum enthält, das einem Samstag oder Sonntag zugeordnet ist:

from functools import wraps

def add_weekend_feature(func):
    @wraps(func)
    def wrapper(df, *args, **kwargs):
        df = df.copy() # Prevents Pandas mutation warnings
        df('is_weekend') = df('date').dt.dayofweek.isin((5, 6)).astype(int)
        return func(df, *args, **kwargs)
    return wrapper

# Utility
@add_weekend_feature
def process_data(df):
    # 'is_weekend' is assured to exist right here
    return df.dropna()

# 4. Deterministischer Samensetzer

Dieses zeichnet sich durch zwei spezifische Phasen des KI-/maschinellen Lernlebenszyklus aus: Experimentieren und Hyperparameter-Tuning. Diese Prozesse erfordern typischerweise die Verwendung eines Zufallsstartwerts als Teil der Anpassung wichtiger Hyperparameter wie der Lernrate eines Modells. Angenommen, Sie haben gerade den Wert angepasst und plötzlich sinkt die Modellgenauigkeit. In einer solchen State of affairs müssen Sie möglicherweise wissen, ob die Ursache für diesen Leistungsabfall die neue Hyperparametereinstellung oder einfach eine fehlerhafte zufällige Initialisierung der Gewichte ist. Indem wir den Seed sperren, isolieren wir Variablen und machen so die Ergebnisse von Checks wie A/B zuverlässiger.

import random, numpy as np
from functools import wraps

def lock_seed(seed=42):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            random.seed(seed)
            np.random.seed(seed)
            return func(*args, **kwargs)
        return wrapper
    return decorator

# Utility
@lock_seed(42)
def initialize_weights():
    return np.random.randn(10, 10)

# 5. Dev-Mode-Fallback

Ein lebensrettender Dekorateur, insbesondere in lokalen Entwicklungsumgebungen und CI/CD-Checks. Angenommen, Sie bauen eine Anwendungsschicht auf einem LLM auf – zum Beispiel ein RAG-System (Retrieval-Augmented Era). Wenn eine dekorierte Funktion aufgrund externer Faktoren wie Verbindungszeitüberschreitungen oder API-Nutzungsbeschränkungen fehlschlägt, wird der Fehler von diesem Dekorator abgefangen und ein vordefinierter Satz von „Mock-Testdaten“ zurückgegeben, anstatt eine Ausnahme auszulösen.

Warum ein Lebensretter? Denn dieser Mechanismus kann sicherstellen, dass Ihre Anwendung nicht vollständig stoppt, wenn ein externer Dienst vorübergehend ausfällt.

from functools import wraps

def fallback_mock(mock_data):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            attempt:
                return func(*args, **kwargs)
            besides Exception: # Catches timeouts and charge limits
                return mock_data
        return wrapper
    return decorator

# Utility
@fallback_mock(mock_data=(0.01, -0.05, 0.02))
def get_text_embeddings(textual content):
    return external_api.embed(textual content)

# Zusammenfassung

In diesem Artikel wurden fünf effektive Python-Dekoratoren untersucht, die dazu beitragen, Ihren KI- und Machine-Studying-Code in einer Vielzahl spezifischer Situationen sauberer zu gestalten: von strukturierter, einfach zu durchsuchender Protokollierung bis hin zu kontrolliertem Zufalls-Seeding für Aspekte wie Datenstichproben, Checks und mehr.

Iván Palomares Carrascosa ist ein führender Autor, Redner und Berater in den Bereichen KI, maschinelles Lernen, Deep Studying und LLMs. Er schult und leitet andere darin, KI in der realen Welt zu nutzen.

Bild vom Herausgeber

# Einführung

Wenn Sie KI-Agenten entwickelt haben, die in Ihrem Pocket book perfekt funktionieren, aber sofort zusammenbrechen, sobald sie in Produktion gehen, sind Sie in guter Gesellschaft. Zeitüberschreitung bei API-Aufrufen, LLM-Antworten (Massive Language Mannequin) kommen fehlerhaft zurück – und Tarifbegrenzungen treten im ungünstigsten Second in Kraft.

Die Realität beim Einsatz von Agenten ist chaotisch, und die meisten Probleme entstehen durch den eleganten Umgang mit Fehlern. Hier ist die Sache: Sie benötigen kein riesiges Framework, um dieses Downside zu lösen. Diese fünf Python-Dekorateure haben mir unzählige Kopfschmerzen erspart, und sie werden wahrscheinlich auch Sie retten.

# 1. Automatischer Wiederholungsversuch mit exponentiellem Backoff

Jeder KI-Agent kommuniziert mit externen APIs, und jede externe API wird bei Ihnen irgendwann scheitern. Möglicherweise gibt OpenAI eine 429 zurück, weil Sie das Ratenlimit erreicht haben, oder es liegt ein kurzer Netzwerkproblem vor. In jedem Fall sollte Ihr Makler nicht gleich beim ersten Misserfolg aufgeben.

A @retry Der Dekorator umschließt jede Funktion, sodass sie beim Auslösen einer bestimmten Ausnahme einen Second wartet und es erneut versucht. Der exponentielle Backoff-Teil ist entscheidend, da die Wartezeit mit jedem Versuch länger werden soll. Der erste Wiederholungsversuch wartet eine Sekunde, der zweite Wiederholungsversuch zwei, der dritte vier Sekunden und so weiter. Dies verhindert, dass Sie eine bereits problematische API überlasten.

Sie können dies mit einem einfachen Wrapper selbst erstellen time.sleep() und eine Schleife, oder greifen Sie zur Tenacity-Bibliothekwas Ihnen einen kampferprobten Charakter verleiht @retry Dekorateur aus der Field. Der Schlüssel liegt darin, es mit den richtigen Ausnahmetypen zu konfigurieren. Sie möchten es nicht bei einer fehlerhaften Eingabeaufforderung erneut versuchen (das schlägt jedes Mal fehl), aber Sie möchten es auf jeden Fall bei Verbindungsfehlern und Antworten mit Ratenbegrenzung erneut versuchen.

# 2. Verwendung von Timeout-Guards

LLM-Aufrufe können hängen bleiben. Es passiert nicht oft, aber wenn doch, sitzt Ihr Agent da und tut nichts, während der Benutzer auf einen Kreisel starrt. Schlimmer noch: Wenn Sie mehrere Agenten parallel betreiben, kann ein einziger hängender Anruf zu einem Engpass in Ihrer gesamten Pipeline führen.

A @timeout Dekorateur legt eine feste Obergrenze dafür fest, wie lange eine Funktion ausgeführt werden darf. Wenn die Funktion nicht innerhalb von beispielsweise 30 Sekunden zurückkehrt, löst der Dekorateur eine aus TimeoutError die Sie fangen und elegant handhaben können. Die typische Implementierung verwendet Pythons sign Modul für synchronen Code oder asyncio.wait_for(), wenn Sie im asynchronen Land arbeiten.

Kombinieren Sie dies mit Ihrem Retry-Decorator und Sie haben eine leistungsstarke Kombination: Wenn ein Anruf hängen bleibt, wird er durch das Timeout abgebrochen und die Retry-Logik setzt mit einem neuen Versuch ein. Dies allein eliminiert eine große Kategorie von Produktionsausfällen.

# 3. Antwort-Caching implementieren

Hier ist etwas, das Ihre API-Kosten drastisch senken wird. Wenn Ihr Agent denselben Anruf mit denselben Parametern mehr als einmal tätigt (was häufig vorkommt, insbesondere in mehrstufigen Argumentationsschleifen), gibt es keinen Grund, für diese Antwort zweimal zu bezahlen.

A @cache Dekorateur speichert das Ergebnis eines Funktionsaufrufs basierend auf seinen Eingabeargumenten. Wenn die Funktion das nächste Mal mit denselben Argumenten aufgerufen wird, gibt der Dekorateur sofort das gespeicherte Ergebnis zurück. Python ist integriert functools.lru_cache Funktioniert hervorragend für einfache Fälle, aber für Agenten-Workflows benötigen Sie etwas mit Time-to-Reside-Unterstützung (TTL), sodass zwischengespeicherte Antworten nach einem angemessenen Zeitfenster ablaufen.

Das ist wichtiger als Sie denken. Agenten, die Device-Aufrufmuster verwenden, überprüfen häufig frühere Ergebnisse erneut oder rufen den Kontext erneut ab, den sie bereits abgerufen haben. Das Zwischenspeichern dieser Anrufe bedeutet eine schnellere Ausführung und eine geringere Rechnung am Monatsende.

# 4. Validierung von Ein- und Ausgängen

Große Sprachmodelle sind von Natur aus unvorhersehbar. Sie senden eine sorgfältig gestaltete Eingabeaufforderung, in der Sie nach JSON fragen, und manchmal erhalten Sie einen Markdown-Codeblock mit einem abschließenden Komma zurück, der Ihren Parser kaputt macht. A @validate Decorator fängt diese Probleme an der Grenze ab, bevor fehlerhafte Daten tiefer in die Logik Ihres Agenten eindringen.

Auf der Eingabeseite prüft der Dekorateur, ob die von Ihrer Funktion empfangenen Argumente mit den erwarteten Typen und Einschränkungen übereinstimmen. Auf der Ausgabeseite wird überprüft, ob der Rückgabewert einem Schema entspricht. während Pydantic dies unglaublich sauber macht. Sie definieren Ihre erwartete Antwort als Pydantic-Modell und der Dekorateur versucht, die LLM-Ausgabe in dieses Modell zu analysieren. Wenn die Validierung fehlschlägt, können Sie den Aufruf wiederholen, eine Korrekturfunktion anwenden oder auf einen Standardwert zurückgreifen.

Der eigentliche Vorteil besteht darin, dass Validierungsdekoratoren stille Datenbeschädigung in laute, erkennbare Fehler verwandeln. Sie beheben Probleme in Minuten statt in Stunden.

# 5. Aufbau von Fallback-Ketten

Produktionsagenten benötigen einen Plan B. Wenn Ihr primäres Modell ausfällt, wenn Ihre Vektordatenbank nicht erreichbar ist, wenn Ihre Device-API Müll zurückgibt, sollte Ihr Agent ordnungsgemäß heruntergefahren werden, anstatt abzustürzen.

A @fallback Dekorateur Hier können Sie eine Kette alternativer Funktionen definieren. Der Dekorateur probiert zuerst die primäre Funktion aus und geht dann, wenn er eine Ausnahme auslöst, zur nächsten Funktion in der Kette über. Sie können einen Fallback von GPT-5.4 auf Claude und ein lokales Llama-Modell einrichten. Oder von einer Reside-Datenbankabfrage über einen zwischengespeicherten Snapshot bis hin zu einem fest codierten Standardwert.

Die Umsetzung ist unkompliziert. Der Dekorateur akzeptiert eine Liste von Fallback-Callables und durchläuft diese bei einem Fehler. Sie können es noch individueller gestalten, indem Sie auf jeder Fallback-Ebene eine Protokollierung hinzufügen, sodass Sie genau wissen, wo und warum Ihr System beeinträchtigt ist. Dieses Muster taucht überall in Produktionssystemen für maschinelles Lernen auf, und wenn man es als Dekorateur einsetzt, bleibt die Logik von Ihrem Geschäftscode getrennt.

# Abschluss

Dekoratoren sind eine der am meisten unterschätzten Funktionen von Python, wenn es um die Entwicklung zuverlässiger KI-Agenten geht. Die fünf hier behandelten Muster behandeln die häufigsten Fehlermodi, denen Sie begegnen, wenn Ihr Agent die Sicherheit eines Jupyter-Notebooks verlässt.

Und sie komponieren wunderbar. Stapeln Sie a @retry oben auf einem @timeout oben auf einem @validateund Sie haben eine Funktion, die nicht hängen bleibt, nicht so schnell aufgibt und fehlerhafte Daten nicht stillschweigend weiterleitet. Fügen Sie noch heute Wiederholungslogik zu Ihren API-Aufrufen hinzu. Sobald Sie sehen, wie viel sauberer Ihre Fehlerbehandlung wird, werden Sie überall Dekorateure wollen.

Nahla Davies ist Softwareentwickler und technischer Autor. Bevor sie sich hauptberuflich dem technischen Schreiben widmete, schaffte sie es – neben anderen faszinierenden Dingen –, als leitende Programmiererin bei einer Inc. 5.000-Organisation für experimentelles Branding zu arbeiten, zu deren Kunden Samsung, Time Warner, Netflix und Sony gehören.

angles = np.linspace(0.0, 2.0 * np.pi, n_particles, endpoint=False, dtype=np.float32)
px0_np = 0.4 * np.cos(angles).astype(np.float32)
py0_np = (0.7 + 0.15 * np.sin(angles)).astype(np.float32)
vx0_np = (-0.8 * np.sin(angles)).astype(np.float32)
vy0_np = (0.8 * np.cos(angles)).astype(np.float32)


px0_wp = wp.array(px0_np, dtype=wp.float32, gadget=gadget)
py0_wp = wp.array(py0_np, dtype=wp.float32, gadget=gadget)
vx0_wp = wp.array(vx0_np, dtype=wp.float32, gadget=gadget)
vy0_wp = wp.array(vy0_np, dtype=wp.float32, gadget=gadget)


state_size = (steps + 1) * n_particles
px_wp = wp.empty(state_size, dtype=wp.float32, gadget=gadget)
py_wp = wp.empty(state_size, dtype=wp.float32, gadget=gadget)
vx_wp = wp.empty(state_size, dtype=wp.float32, gadget=gadget)
vy_wp = wp.empty(state_size, dtype=wp.float32, gadget=gadget)


wp.launch(
   kernel=init_particles_kernel,
   dim=n_particles,
   inputs=(n_particles, px0_wp, py0_wp, vx0_wp, vy0_wp),
   outputs=(px_wp, py_wp, vx_wp, vy_wp),
   gadget=gadget,
)


wp.launch(
   kernel=simulate_particles_kernel,
   dim=steps * n_particles,
   inputs=(n_particles, dt, gravity, damping, bounce, radius),
   outputs=(px_wp, py_wp, vx_wp, vy_wp),
   gadget=gadget,
)
wp.synchronize()


px_traj = px_wp.numpy().reshape(steps + 1, n_particles)
py_traj = py_wp.numpy().reshape(steps + 1, n_particles)


sample_ids = np.linspace(0, n_particles - 1, 16, dtype=int)
plt.determine(figsize=(8, 6))
for idx in sample_ids:
   plt.plot(px_traj(:, idx), py_traj(:, idx), linewidth=1.5)
plt.axhline(radius, linestyle="--")
plt.xlim(-1.05, 1.05)
plt.ylim(0.0, 1.25)
plt.title(f"Warp particle trajectories on {gadget}")
plt.xlabel("x")
plt.ylabel("y")
plt.present()


proj_steps = 180
proj_dt = np.float32(0.025)
proj_g = np.float32(-9.8)
target_x = np.float32(3.8)
target_y = np.float32(0.0)


vx_value = np.float32(2.0)
vy_value = np.float32(6.5)
lr = 0.08
iters = 60


loss_history = ()
vx_history = ()
vy_history = ()


for it in vary(iters):
   init_vx_wp = wp.array(np.array((vx_value), dtype=np.float32), dtype=wp.float32, gadget=gadget, requires_grad=True)
   init_vy_wp = wp.array(np.array((vy_value), dtype=np.float32), dtype=wp.float32, gadget=gadget, requires_grad=True)


   x_hist_wp = wp.zeros(proj_steps + 1, dtype=wp.float32, gadget=gadget, requires_grad=True)
   y_hist_wp = wp.zeros(proj_steps + 1, dtype=wp.float32, gadget=gadget, requires_grad=True)
   vx_hist_wp = wp.zeros(proj_steps + 1, dtype=wp.float32, gadget=gadget, requires_grad=True)
   vy_hist_wp = wp.zeros(proj_steps + 1, dtype=wp.float32, gadget=gadget, requires_grad=True)
   loss_wp = wp.zeros(1, dtype=wp.float32, gadget=gadget, requires_grad=True)


   tape = wp.Tape()
   with tape:
       wp.launch(
           kernel=init_projectile_kernel,
           dim=1,
           inputs=(),
           outputs=(x_hist_wp, y_hist_wp, vx_hist_wp, vy_hist_wp, init_vx_wp, init_vy_wp),
           gadget=gadget,
       )
       wp.launch(
           kernel=projectile_step_kernel,
           dim=proj_steps,
           inputs=(proj_dt, proj_g),
           outputs=(x_hist_wp, y_hist_wp, vx_hist_wp, vy_hist_wp),
           gadget=gadget,
       )
       wp.launch(
           kernel=projectile_loss_kernel,
           dim=1,
           inputs=(proj_steps, target_x, target_y),
           outputs=(x_hist_wp, y_hist_wp, loss_wp),
           gadget=gadget,
       )


   tape.backward(loss=loss_wp)
   wp.synchronize()


   current_loss = float(loss_wp.numpy()(0))
   grad_vx = float(init_vx_wp.grad.numpy()(0))
   grad_vy = float(init_vy_wp.grad.numpy()(0))


   vx_value = np.float32(vx_value - lr * grad_vx)
   vy_value = np.float32(vy_value - lr * grad_vy)


   loss_history.append(current_loss)
   vx_history.append(float(vx_value))
   vy_history.append(float(vy_value))


   if it % 10 == 0 or it == iters - 1:
       print(f"iter={it:02d} loss={current_loss:.6f} vx={vx_value:.4f} vy={vy_value:.4f} grad=({grad_vx:.4f}, {grad_vy:.4f})")


final_init_vx_wp = wp.array(np.array((vx_value), dtype=np.float32), dtype=wp.float32, gadget=gadget)
final_init_vy_wp = wp.array(np.array((vy_value), dtype=np.float32), dtype=wp.float32, gadget=gadget)
x_hist_wp = wp.zeros(proj_steps + 1, dtype=wp.float32, gadget=gadget)
y_hist_wp = wp.zeros(proj_steps + 1, dtype=wp.float32, gadget=gadget)
vx_hist_wp = wp.zeros(proj_steps + 1, dtype=wp.float32, gadget=gadget)
vy_hist_wp = wp.zeros(proj_steps + 1, dtype=wp.float32, gadget=gadget)


wp.launch(
   kernel=init_projectile_kernel,
   dim=1,
   inputs=(),
   outputs=(x_hist_wp, y_hist_wp, vx_hist_wp, vy_hist_wp, final_init_vx_wp, final_init_vy_wp),
   gadget=gadget,
)
wp.launch(
   kernel=projectile_step_kernel,
   dim=proj_steps,
   inputs=(proj_dt, proj_g),
   outputs=(x_hist_wp, y_hist_wp, vx_hist_wp, vy_hist_wp),
   gadget=gadget,
)
wp.synchronize()


x_path = x_hist_wp.numpy()
y_path = y_hist_wp.numpy()


fig = plt.determine(figsize=(15, 4))


ax1 = fig.add_subplot(1, 3, 1)
ax1.plot(loss_history)
ax1.set_title("Optimization loss")
ax1.set_xlabel("Iteration")
ax1.set_ylabel("Squared distance")


ax2 = fig.add_subplot(1, 3, 2)
ax2.plot(vx_history, label="vx")
ax2.plot(vy_history, label="vy")
ax2.set_title("Discovered preliminary velocity")
ax2.set_xlabel("Iteration")
ax2.legend()


ax3 = fig.add_subplot(1, 3, 3)
ax3.plot(x_path, y_path, linewidth=2)
ax3.scatter((target_x), (target_y), s=80, marker="x")
ax3.set_title("Differentiable projectile trajectory")
ax3.set_xlabel("x")
ax3.set_ylabel("y")
ax3.set_ylim(-0.1, max(1.0, float(np.max(y_path)) + 0.3))


plt.tight_layout()
plt.present()


final_dx = float(x_path(-1) - target_x)
final_dy = float(y_path(-1) - target_y)
final_dist = math.sqrt(final_dx * final_dx + final_dy * final_dy)
print(f"Remaining goal miss distance: {final_dist:.6f}")
print(f"Optimized preliminary velocity: vx={vx_value:.6f}, vy={vy_value:.6f}")

Bild vom Herausgeber

# Einführung

Datenpipelines in Information-Science- und Machine-Studying-Projekten sind eine sehr praktische und vielseitige Möglichkeit, Datenverarbeitungsabläufe zu automatisieren. Aber manchmal kann unser Code der Kernlogik zusätzliche Komplexität verleihen. Python-Dekoratoren können diese gemeinsame Herausforderung meistern. In diesem Artikel werden fünf nützliche und effektive Python-Dekoratoren zum Erstellen und Optimieren leistungsstarker Datenpipelines vorgestellt.

Dieser Präambelcode geht den Codebeispielen voraus, die den fünf Dekoratoren beiliegen, um eine Model des California Housing-Datensatzes zu laden, den ich für Sie in einem öffentlichen GitHub-Repository zur Verfügung gestellt habe:

import pandas as pd
import numpy as np

# Loading the dataset
DATA_URL = "https://uncooked.githubusercontent.com/gakudo-ai/open-datasets/important/housing.csv"

print("Downloading information pipeline supply...")
df_pipeline = pd.read_csv(DATA_URL)
print(f"Loaded {df_pipeline.form(0)} rows and {df_pipeline.form(1)} columns.")

# 1. JIT-Kompilierung

Während Python-Schleifen den zweifelhaften Ruf haben, bemerkenswert langsam zu sein und bei der Durchführung komplexer Operationen wie mathematischen Transformationen in einem Datensatz Engpässe zu verursachen, gibt es eine schnelle Lösung. Es heißt @njitund es ist ein Dekorateur in der Numba Bibliothek, die Python-Funktionen zur Laufzeit in C-ähnlichen, optimierten Maschinencode übersetzt. Bei großen Datensätzen und komplexen Datenpipelines kann dies drastische Beschleunigungen bedeuten.

from numba import njit
import time

# Extracting a numeric column as a NumPy array for quick processing
incomes = df_pipeline('median_income').fillna(0).values

@njit
def compute_complex_metric(income_array):
    outcome = np.zeros_like(income_array)
    # In pure Python, a loop like this could usually drag
    for i in vary(len(income_array)):
        outcome(i) = np.log1p(income_array(i) * 2.5) ** 1.5
    return outcome

begin = time.time()
df_pipeline('income_metric') = compute_complex_metric(incomes)
print(f"Processed array in {time.time() - begin:.5f} seconds!")

# 2. Zwischen-Caching

Wenn Datenpipelines rechenintensive Aggregationen oder Datenverknüpfungen enthalten, deren Ausführung Minuten bis Stunden dauern kann, reminiscence.cache kann zur Serialisierung von Funktionsausgaben verwendet werden. Im Falle eines Neustarts des Skripts oder einer Wiederherstellung nach einem Absturz kann dieser Dekorator serialisierte Array-Daten von der Festplatte neu laden, wodurch aufwändige Berechnungen übersprungen werden und nicht nur Ressourcen, sondern auch Zeit gespart werden.

from joblib import Reminiscence
import time

# Creating an area cache listing for pipeline artifacts
reminiscence = Reminiscence(".pipeline_cache", verbose=0)

@reminiscence.cache
def expensive_aggregation(df):
    print("Working heavy grouping operation...")
    time.sleep(1.5) # Lengthy-running pipeline step simulation
    # Grouping information factors by ocean_proximity and calculating attribute-level means
    return df.groupby('ocean_proximity', as_index=False).imply(numeric_only=True)

# The primary run executes the code; the second resorts to disk for immediate loading
agg_df = expensive_aggregation(df_pipeline)
agg_df_cached = expensive_aggregation(df_pipeline)

# 3. Schemavalidierung

Pandera ist eine statistische Typisierungsbibliothek (Schemaüberprüfung), die dazu konzipiert ist, die allmähliche, subtile Beschädigung von Analysemodellen wie maschinellen Lernprädiktoren oder Dashboards aufgrund schlechter Datenqualität zu verhindern. Im folgenden Beispiel reicht es aus, es in Kombination mit der Parallelverarbeitung zu verwenden Dask Bibliothek, um zu überprüfen, ob die anfängliche Pipeline dem angegebenen Schema entspricht. Wenn nicht, wird ein Fehler ausgegeben, um potenzielle Probleme frühzeitig zu erkennen.

import pandera as pa
import pandas as pd
import numpy as np
from dask import delayed, compute

# Outline a schema to implement information varieties and legitimate ranges
housing_schema = pa.DataFrameSchema({
    "median_income": pa.Column(float, pa.Test.greater_than(0)),
    "total_rooms": pa.Column(float, pa.Test.gt(0)),
    "ocean_proximity": pa.Column(str, pa.Test.isin(('NEAR BAY', '<1H OCEAN', 'INLAND', 'NEAR OCEAN', 'ISLAND')))
})

@delayed
@pa.check_types
def validate_and_process(df: pa.typing.DataFrame) -> pa.typing.DataFrame:
    """
    Validates the dataframe chunk in opposition to the outlined schema.
    If the information is corrupt, Pandera raises a SchemaError.
    """
    return housing_schema.validate(df)

# Splitting the pipeline information into 4 chunks for parallel validation
chunks = np.array_split(df_pipeline, 4)
lazy_validations = (validate_and_process(chunk) for chunk in chunks)

print("Beginning parallel schema validation...")
attempt:
    # Triggering the Dask graph to validate chunks in parallel
    validated_chunks = compute(*lazy_validations)
    df_parallel = pd.concat(validated_chunks)
    print(f"Validation profitable. Processed {len(df_parallel)} rows.")
besides pa.errors.SchemaError as e:
    print(f"Information Integrity Error: {e}")

# 4. Faule Parallelisierung

Durch die sequentielle Ausführung unabhängiger Pipeline-Schritte werden Verarbeitungseinheiten wie CPUs möglicherweise nicht optimum genutzt. Der @delayed Der Decorator erstellt zusätzlich zu solchen Transformationsfunktionen einen Abhängigkeitsgraphen, um die Aufgaben später auf optimierte Weise parallel auszuführen, was zur Verkürzung der Gesamtlaufzeit beiträgt.

from dask import delayed, compute

@delayed
def process_chunk(df_chunk):
    # Simulating an remoted transformation job
    df_chunk_copy = df_chunk.copy()
    df_chunk_copy('value_per_room') = df_chunk_copy('median_house_value') / df_chunk_copy('total_rooms')
    return df_chunk_copy

# Splitting the dataset into 4 chunks processed in parallel
chunks = np.array_split(df_pipeline, 4)

# Lazy computation graph (the way in which Dask works!)
lazy_results = (process_chunk(chunk) for chunk in chunks)

# Set off execution throughout a number of CPUs concurrently
processed_chunks = compute(*lazy_results)
df_parallel = pd.concat(processed_chunks)
print(f"Parallelized output form: {df_parallel.form}")

# 5. Speicherprofilierung

Der @profile Decorator soll dabei helfen, stille Speicherlecks zu erkennen – die manchmal zum Absturz von Servern führen können, wenn die zu verarbeitenden Dateien sehr groß sind. Das Muster besteht darin, die verpackte Funktion Schritt für Schritt zu überwachen und bei jedem einzelnen Schritt die Höhe des RAM-Verbrauchs oder des freigegebenen Speichers zu beobachten. Letztendlich ist dies eine großartige Möglichkeit, Ineffizienzen im Code leicht zu erkennen und die Speichernutzung mit einer klaren Richtung vor Augen zu optimieren.

from memory_profiler import profile

# A adorned operate that prints a line-by-line reminiscence breakdown to the console
@profile(precision=2)
def memory_intensive_step(df):
    print("Working reminiscence diagnostics...")
    # Creation of a large short-term copy to trigger an intentional reminiscence spike
    df_temp = df.copy() 
    df_temp('new_col') = df_temp('total_bedrooms') * 100
    
    # Dropping the short-term dataframe frees up the RAM
    del df_temp 
    return df.dropna(subset=('total_bedrooms'))

# Working the pipeline step: it's possible you'll observe the reminiscence report in your terminal
final_df = memory_intensive_step(df_pipeline)

# Zusammenfassung

In diesem Artikel werden fünf nützliche und leistungsstarke Python-Dekoratoren zur Optimierung rechenintensiver Datenpipelines vorgestellt. Unterstützt durch paralleles Rechnen und effiziente Verarbeitungsbibliotheken wie Dask und Numba können diese Dekoratoren nicht nur umfangreiche Datentransformationsprozesse beschleunigen, sondern sie auch widerstandsfähiger gegen Fehler und Ausfälle machen.

Iván Palomares Carrascosa ist ein führender Autor, Redner und Berater in den Bereichen KI, maschinelles Lernen, Deep Studying und LLMs. Er schult und leitet andere darin, KI in der realen Welt zu nutzen.

Bild vom Herausgeber

# Einführung

Python-Dekoratoren sind maßgeschneiderte Lösungen, die dazu beitragen sollen, komplexe Softwarelogik in einer Vielzahl von Anwendungen, einschließlich LLM-basierten Anwendungen, zu vereinfachen. Der Umgang mit LLMs erfordert oft den Umgang mit unvorhersehbaren, langsamen – und häufig teuren – APIs von Drittanbietern, und Dekorateure haben viel zu bieten, um diese Aufgabe sauberer zu gestalten, indem sie beispielsweise API-Aufrufe mit optimierter Logik umschließen.

Werfen wir einen Blick auf fünf nützliche Python-Dekoratoren, die Ihnen dabei helfen, Ihre LLM-basierten Anwendungen ohne spürbaren Mehraufwand zu optimieren.

Die beigefügten Beispiele veranschaulichen die Syntax und den Ansatz zur Verwendung jedes Dekorators. Sie werden manchmal ohne tatsächliche LLM-Nutzung gezeigt, es handelt sich jedoch um Codeauszüge, die letztendlich als Teil größerer Anwendungen konzipiert sind.

# 1. In-Reminiscence-Caching

Diese Lösung stammt von Python functools Standardbibliothek und ist nützlich für teure Funktionen wie solche, die LLMs verwenden. Wenn wir einen LLM-API-Aufruf in der unten definierten Funktion hätten, fügt das Einschließen in einen LRU-Dekorator (Least Current Used) einen Cache-Mechanismus hinzu, der verhindert, dass redundante Anforderungen identische Eingaben (Eingabeaufforderungen) in derselben Ausführung oder Sitzung enthalten. Dies ist eine elegante Möglichkeit, Latenzprobleme zu optimieren.

Dieses Beispiel veranschaulicht seine Verwendung:

from functools import lru_cache
import time

@lru_cache(maxsize=100)
def summarize_text(textual content: str) -> str:
    print("Sending textual content to LLM...")
    time.sleep(1) # A simulation of community delay
    return f"Abstract of {len(textual content)} characters."

print(summarize_text("The fast brown fox.")) # Takes one second
print(summarize_text("The fast brown fox.")) # Instantaneous

# 2. Caching auf persistenter Festplatte

Apropos Caching, die externe Bibliothek diskcache geht noch einen Schritt weiter und implementiert einen persistenten Cache auf der Festplatte, und zwar über eine SQLite-Datenbank: sehr nützlich zum Speichern von Ergebnissen zeitaufwändiger Funktionen wie LLM-API-Aufrufe. Auf diese Weise können Ergebnisse bei späteren Anrufen bei Bedarf schnell abgerufen werden. Erwägen Sie die Verwendung dieses Dekorationsmusters, wenn die Zwischenspeicherung im Arbeitsspeicher nicht ausreicht, weil die Ausführung eines Skripts oder einer Anwendung möglicherweise gestoppt wird.

import time
from diskcache import Cache

# Creating a light-weight native SQLite database listing
cache = Cache(".local_llm_cache")

@cache.memoize(expire=86400) # Cached for twenty-four hours
def fetch_llm_response(immediate: str) -> str:
    print("Calling costly LLM API...") # Substitute this by an precise LLM API name
    time.sleep(2) # API latency simulation
    return f"Response to: {immediate}"

print(fetch_llm_response("What's quantum computing?")) # 1st operate name
print(fetch_llm_response("What's quantum computing?")) # Instantaneous load from disk occurs right here!

# 3. Netzwerkstabile Apps

Da LLMs aufgrund vorübergehender Fehler sowie Zeitüberschreitungen und „502 Dangerous Gateway“-Antworten im Web häufig ausfallen können, ist die Verwendung einer Netzwerk-Resilienzbibliothek wie z tenacity zusammen mit dem @retry Decorator kann dabei helfen, diese häufigen Netzwerkfehler abzufangen.

Das folgende Beispiel veranschaulicht diese Implementierung von robustem Verhalten durch zufällige Simulation einer 70-prozentigen Wahrscheinlichkeit eines Netzwerkfehlers. Versuchen Sie es mehrmals, und früher oder später wird dieser Fehler auftreten: völlig erwartet und beabsichtigt!

import random
from tenacity import retry, wait_exponential, stop_after_attempt, retry_if_exception_type

class RateLimitError(Exception): cross

# Retrying as much as 4 instances, ready 2, 4, and eight seconds between every try
@retry(
    wait=wait_exponential(multiplier=2, min=2, max=10),
    cease=stop_after_attempt(4),
    retry=retry_if_exception_type(RateLimitError)
)
def call_flaky_llm_api(immediate: str):
    print("Making an attempt to name API...")
    if random.random() < 0.7: # Simulating a 70% probability of API failure
        increase RateLimitError("Price restrict exceeded! Backing off.")
    return "Textual content has been efficiently generated!"

print(call_flaky_llm_api("Write a haiku"))

# 4. Clientseitige Drosselung

Dieser kombinierte Dekorateur verwendet die ratelimit Bibliothek zum Steuern der Häufigkeit von Aufrufen einer (normalerweise stark nachgefragten) Funktion: nützlich, um clientseitige Einschränkungen bei der Verwendung externer APIs zu vermeiden. Im folgenden Beispiel werden dazu Grenzwerte für Anfragen professional Minute (RPM) definiert. Der Anbieter lehnt Eingabeaufforderungen einer Clientanwendung ab, wenn zu viele Eingabeaufforderungen gleichzeitig gestartet werden.

from ratelimit import limits, sleep_and_retry
import time

# Strictly imposing a 3-call restrict per 10-second window
@sleep_and_retry
@limits(calls=3, interval=10)
def generate_text(immediate: str) -> str:
    print(f"({time.strftime('%X')}) Processing: {immediate}")
    return f"Processed: {immediate}"

# First 3 print instantly, the 4th pauses, thereby respecting the restrict
for i in vary(5):
    generate_text(f"Immediate {i}")

# 5. Strukturierte Ausgabebindung

Der fünfte Dekorateur auf der Liste verwendet die magentic Bibliothek in Verbindung mit Pydantic Bereitstellung eines effizienten Interaktionsmechanismus mit LLMs über API und Erhalt strukturierter Antworten. Es vereinfacht den Prozess des Aufrufs von LLM-APIs. Dieser Prozess ist wichtig, um LLMs dazu zu bringen, formatierte Daten wie JSON-Objekte zuverlässig zurückzugeben. Der Dekorateur würde sich um die zugrunde liegenden Systemeingabeaufforderungen und das von Pydantic geleitete Parsen kümmern, wodurch die Verwendung von Token optimiert und dazu beigetragen würde, eine sauberere Codebasis zu erhalten.

Um dieses Beispiel auszuprobieren, benötigen Sie einen OpenAI-API-Schlüssel.

# IMPORTANT: An OPENAI_API_KEY set is required to run this simulated instance
from magentic import immediate
from pydantic import BaseModel

class CapitalInfo(BaseModel):
    capital: str
    inhabitants: int

# A decorator that simply maps the immediate to the Pydantic return kind
@immediate("What's the capital and inhabitants of {nation}?")
def get_capital_info(nation: str) -> CapitalInfo:
    ... # No operate physique wanted right here!

data = get_capital_info("France")
print(f"Capital: {data.capital}, Inhabitants: {data.inhabitants}")

# Zusammenfassung

In diesem Artikel haben wir fünf Python-Dekoratoren aufgelistet und illustriert, die auf verschiedenen Bibliotheken basieren und denen eine besondere Bedeutung zukommt, wenn sie im Kontext LLM-basierter Anwendungen verwendet werden, um unter anderem die Logik zu vereinfachen, Prozesse effizienter zu gestalten oder die Netzwerkstabilität zu verbessern.

Iván Palomares Carrascosa ist ein führender Autor, Redner und Berater in den Bereichen KI, maschinelles Lernen, Deep Studying und LLMs. Er schult und leitet andere darin, KI in der realen Welt zu nutzen.

Da sich die Branche von einfachen LLM-Inferenzen (Giant Language Mannequin) hin zu autonomen Agentensystemen bewegt, haben sich die Herausforderungen für Entwickler verändert. Es geht nicht mehr nur um das Modell; es geht um die Umgebung, in der dieses Modell funktioniert. Ein Forscherteam von Alibaba veröffentlicht CoPawein Open-Supply-Framework, das dieses Downside lösen soll, indem es eine standardisierte Workstation für die Bereitstellung und Verwaltung persönlicher KI-Agenten bereitstellt.

CoPaw basiert auf einem technischen Stack bestehend aus AgentScope, AgentScope-LaufzeitUnd ReMe. Es fungiert als Brücke zwischen der Agentenlogik auf hoher Ebene und den praktischen Anforderungen eines persönlichen Assistenten, wie z. B. persistenter Speicher, Mehrkanalkonnektivität und Aufgabenplanung.

Die Architektur: AgentScope- und ReMe-Integration

CoPaw ist kein eigenständiger Bot, sondern eine Workstation, die mehrere Komponenten orchestriert, um eine zusammenhängende „Agenten-App“ zu erstellen.

Das System basiert auf drei Hauptschichten:

1. AgentScope: Das zugrunde liegende Framework, das die Agentenkommunikation und -logik verwaltet.
2. AgentScope-Laufzeit: Die Ausführungsumgebung, die einen stabilen Betrieb und ein stabiles Ressourcenmanagement gewährleistet.
3. ReMe (Speicherverwaltung): Ein spezialisiertes Modul, das sowohl lokalen als auch cloudbasierten Speicher verwaltet. Dadurch können Agenten eine „Langzeiterfahrung“ aufrechterhalten und das mit Customary-LLM-APIs verbundene Downside der Zustandslosigkeit lösen.

Durch Hebelwirkung ReMeMit CoPaw können Benutzer ihren Datenschutz kontrollieren und gleichzeitig sicherstellen, dass der Agent den Kontext über verschiedene Sitzungen und Plattformen hinweg behält. Dieser dauerhafte Speicher ermöglicht es der Workstation, sich im Laufe der Zeit an die spezifischen Arbeitsabläufe eines Benutzers anzupassen.

Erweiterbarkeit über das Abilities System

Ein Kernmerkmal der CoPaw-Workstation ist ihre Kompetenzerweiterung Fähigkeit. In diesem Rahmen ist eine „Fähigkeit“ eine diskrete Funktionseinheit – im Wesentlichen ein Werkzeug, das der Agent aufrufen kann, um mit der Außenwelt zu interagieren.

Das Hinzufügen von Funktionen zu CoPaw erfordert keine Änderung der Kern-Engine. Stattdessen unterstützt CoPaw a Benutzerdefiniertes Ability-Verzeichnis wo Ingenieure Python-basierte Funktionen löschen können. Diese Fähigkeiten folgen einer standardisierten Spezifikation (beeinflusst von anthropics/expertise), wodurch der Agent Folgendes tun kann:

• Führen Sie Net Scraping durch (z. B. Zusammenfassung von Reddit-Threads oder YouTube-Movies).
• Interagieren Sie mit lokalen Dateien und Desktop-Umgebungen.
• Fragen Sie persönliche Wissensdatenbanken ab, die auf der Workstation gespeichert sind.
• Verwalten Sie Kalender und E-Mails in natürlicher Sprache.

Dieses Design ermöglicht die Erstellung von Agentische Apps– komplexe Arbeitsabläufe, bei denen der Agent eine Kombination aus integrierten Fähigkeiten und geplanten Aufgaben nutzt, um ein Ziel autonom zu erreichen.

Multi-Channel-Konnektivität (All-Area-Zugriff)

Eine der größten technischen Hürden bei der persönlichen KI ist der Einsatz auf fragmentierten Kommunikationsplattformen. CoPaw begegnet diesem Downside durch seine All-Area-Zugriff Schicht, die standardisiert, wie Agenten mit verschiedenen Messaging-Protokollen interagieren.

Derzeit unterstützt CoPaw die Integration mit:

• Unternehmensplattformen: DingTalk und Lark (Feishu).
• Soziale/Entwicklerplattformen: Discord, QQ und iMessage.

Diese Mehrkanalunterstützung bedeutet, dass ein Entwickler eine einzelne CoPaw-Instanz initialisieren und von jedem dieser Endpunkte aus mit ihr interagieren kann. Die Workstation übernimmt die Übersetzung von Nachrichten zwischen der Logik des Agenten und der API des spezifischen Kanals und sorgt für einen konsistenten Zustand und Speicher, unabhängig davon, wo die Interaktion stattfindet.

Wichtige Erkenntnisse

• Wechsel vom Modell zur Workstation: CoPaw verlagert den Fokus weg vom reinen Giant Language Mannequin (LLM) hin zu einem strukturierten Modell Workstation-Architektur. Es fungiert als Middleware-Schicht, die das orchestriert AgentScope Rahmen, AgentScope-Laufzeitund externe Kommunikationskanäle, um die reinen LLM-Funktionen in einen funktionalen, dauerhaften Assistenten zu verwandeln.
• Langzeitgedächtnis über ReMe: Im Gegensatz zu standardmäßigen zustandslosen LLM-Interaktionen integriert CoPaw die ReMe (Speicherverwaltung) Modul. Dadurch können Agenten eine „Langzeiterfahrung“ aufrechterhalten, indem sie Benutzerpräferenzen und vergangene Aufgabendaten entweder lokal oder in der Cloud speichern und so eine personalisierte Entwicklung des Verhaltens des Agenten im Laufe der Zeit ermöglichen.
• Erweiterbare Python-basierte „Fähigkeiten“: Das Framework verwendet eine entkoppelte Fähigkeitserweiterungssystem basierend auf der anthropics/expertise Spezifikation. Entwickler können den Nutzen eines Agenten erweitern, indem sie einfach Python-Funktionen zu einem benutzerdefinierten Ability-Verzeichnis hinzufügen, sodass der Agent bestimmte Aufgaben wie Net Scraping, Dateimanipulation oder API-Integrationen ausführen kann, ohne die Kerncodebasis zu ändern.
• All-Area-Multi-Channel-Zugriff: CoPaw bietet eine einheitliche Schnittstelle für plattformübergreifende Bereitstellung. Eine einzelne Workstation-Instanz kann mit Unternehmenstools (Lark, DingTalk) und sozialen/Entwicklerplattformen (Discord, QQ, iMessage) verbunden werden, sodass in verschiedenen Umgebungen auf denselben Agenten und seinen Speicher zugegriffen werden kann.
• Automatisierte Agenten-Workflows: Durch Kombinieren Geplante Aufgaben Mit dem Abilities-System geht CoPaw vom reaktiven Chat zur proaktiven Automatisierung über. Entwickler können „Agentic Apps“ programmieren, die Hintergrundvorgänge ausführen – wie etwa die tägliche Forschungssynthese oder die automatisierte Repository-Überwachung – und Ergebnisse an den bevorzugten Kommunikationskanal des Benutzers weiterleiten.

Schauen Sie sich das an Repo hier Und Webseite. Sie können uns auch gerne weiter folgen Twitter und vergessen Sie nicht, bei uns mitzumachen 120.000+ ML SubReddit und Abonnieren Unser E-newsletter. Warten! Bist du im Telegram? Jetzt können Sie uns auch per Telegram kontaktieren.

Künstliche Intelligenz-Instruments entwickeln sich rasant weiter, aber die wirklichen Produktivitätssteigerungen ergeben sich nicht aus der Verwendung eines einzigen Instruments. Die wahre Stärke dieser Instruments ergibt sich aus der gemeinsamen Verwendung. Google NotebookLM ist auf strukturierte Wissenssynthese spezialisiert und hilft Nutzern dabei, kuratierte Quellen zu analysieren, Zusammenfassungen zu erstellen und komplexes Materials zu klären. LM Studio bietet einen privaten lokalen Arbeitsbereich zum Ausführen offener LLMs und ermöglicht so schnelles Experimentieren und iterative Inhaltserstellung.

Zusammen bilden sie einen praktischen Workflow: LM Studio zum Erkunden und Generieren, NotebookLM zum Organisieren und Verstehen. In diesem Artikel zeigen wir anhand praktischer Beispiele, wie diese Paarung die Forschung und Wissensarbeit in der Praxis unterstützt.

Die komplementären Rollen verstehen

Versuchen wir zunächst, die Rolle der einzelnen Instruments aufzuschlüsseln, um besser zu verstehen, was wir durch ihre Kombination erreichen können.

NotebookLM: Quellenbasierte Wissensinteraktion

NotebookLM nutzt den Einsatz kontextueller Intelligenz, um Antworten zu generieren. Im Gegensatz zur Erstellung von Antworten auf der Grundlage generisch trainierter Daten werden nur von Ihnen bereitgestellte Materialien verwendet, darunter PDF-Dateien, Google Docs, Hyperlinks oder Transkripte. Einige der wichtigsten Funktionen von NotebookLM sind:

• Kann Zusammenfassungen bereitstellen, die den Kontext verwenden
• Zitiernachweis für eine Antwort
• Möglichkeit, Lernkarten und Quiz zu erstellen
• Kann einen Studienführer erstellen
• Die Fähigkeit, über mehrere Quellen hinweg zu argumentieren

NotebookLM lässt sich am besten nutzen, wenn Sie über Materials verfügen, das Sie vor der Verwendung der Anwendung kuratiert haben.

LM Studio: Lokale KI-Explorations-Engine

LM Studio ermöglicht es Benutzern, Sprachmodelle auf ihrem Laptop zu verwenden, anstatt auf einen Cloud-basierten Zugriff angewiesen zu sein, und ermöglicht so eine Echtzeitinteraktion mit privaten Daten. Zu den wichtigsten Fähigkeiten gehören:

• Experimentieren mit Eingabeaufforderungen
• Inhalte generieren
• Erstellung technischer Dokumente
• Neue Ideen erkunden
• Modelle offline verwenden
• Modellparameter optimieren

Es eignet sich perfekt zum Generieren/Verfeinern von Wissen, bevor es in ein strukturiertes Format überführt wird.

Warum LM Studio mit NotebookLM koppeln?

NotebookLM eignet sich hervorragend für strukturiertes Lernen. Sie können Dokumente hochladen und erhalten Antworten mit Zitaten auf Ihre Fragen. Es kann Forschungsergebnisse zusammenfassen, wichtige Konzepte hervorheben, Studienführer erstellen usw. Allerdings muss die KI von NotebookLM, die mithilfe der Gemini-Modelle von Google erstellt wird, auf das Web/die Cloud zugreifen. Außerdem kann es Einschränkungen bei Ihrer Nutzung oder Paywalls geben. Im Gegensatz dazu ermöglicht Ihnen LM Studio die Verwendung eines KI-Modells wie GPT-OSS direkt von Ihrem Laptop aus. Vorteile hierfür sind:

• Geschwindigkeit und Verfügbarkeit: Lokale LLMs laufen ohne Netzwerklatenz. Komplexe Abfragen werden in der Regel schneller ausgeführt als sonst, und Sie können diese Vorgänge auch offline oder ohne Rückgriff auf externe Entitäten ausführen.
• Datenschutz und Kontrolle: Wenn Sie LM Studio verwenden, bleiben die Daten nach der Eingabe einer Eingabeaufforderung auf Ihrem lokalen Laptop, es sei denn, Sie entscheiden sich ausdrücklich für die Freigabe. Außerdem lernt das LM Studio-Modell standardmäßig nicht aus Ihren Gesprächen und stellt keine Nutzungsstatistiken bereit, was bedeutet, dass alles, was Sie mit LM Studio tun, für Sie privat bleibt.
• Kosten und Flexibilität: Alle in LM Studio bereitgestellten Open-Supply-Modelle (z. B. GPT-OSS von OpenAI) können kostenlos verwendet werden und können bei Bedarf aktualisiert werden. Sie haben die Freiheit, mit mehreren Modellgrößen (20B vs. 120B) zu experimentieren und Geschwindigkeit vs. Genauigkeit abzuwägen.
• Iteration und tiefe Einblicke: Mit LM Studio ist Ihr Token-Restrict kein Drawback, wenn es darum geht, lange Beschreibungen zu generieren oder den eingegebenen Textual content mehrfach zu iterieren. Sie können das destillierte Materials zur strukturierten Überprüfung Ihrer Inhalte an NotebookLM übergeben.

Die Verwendung von LM Studio ist eine einfache Möglichkeit, neue Ideen schnell zu erkunden, während NotebookLM als Ihr Lernpartner dient. Aufgrund seines „quellenbasierten“ Ansatzes verweisen alle Antworten in NotebookLM auf die von Ihnen hochgeladenen Notizen, was es zu einer wertvollen Ressource bei der Suche nach glaubwürdigen Informationen zum Lernen macht. Viele der neuen Funktionen, die NotebookLM hinzugefügt wurden, wie Lernkarten und Quizze, ermöglichen es Ihnen, Ihre Informationen in eine unterhaltsame und ansprechende Artwork des Lernens umzuwandeln.

Erste Schritte mit NotebookLM und LM Studio

• Laden Sie LM Studio herunter: Sie müssen auf die Web site von LM Studio zugreifen, um die Installationsdatei herunterzuladen, die Ihren Betriebssystemanforderungen entspricht, entweder Home windows, macOS oder Linux. Sie müssen das Installationsprogramm ausführen, um LM Studio zu starten. Die Anwendung erfordert Ihre Zustimmung zu Sicherheitsabfragen, bevor Sie die Desktop-Anwendung bedienen können, die die Modellverwaltung ermöglicht.

• Installieren Sie ein Modell (z. B. GPT-OSS-20B): Gehen Sie in LM Studio zum Bedienfeld „Entdecken“ oder „Modelle“. Sie können nach openai/gpt-oss-20b (OpenAIs Open-Supply-20B-Modell) suchen und klicken, um es herunterzuladen oder zu „holen“. Sie können das Modell nach der Set up des lms-Instruments über die LM Studio-CLI abrufen, indem Sie Folgendes ausführen:

lms get openai/gpt-oss-20b 

Dieser Befehl ruft das Modell ab. Das Modell kann geladen werden über:

lms load openai/gpt-oss-20b 

• Nach Abschluss des Ladevorgangs kann auf das Modell entweder über die LM Studio-Chat-Schnittstelle oder den CLI-Chat-Befehl zugegriffen werden. Die Befehlsstruktur erfordert die Eingabe des folgenden Befehls:

 lms chat openai/gpt-oss-20b 

• Benutzer sollten über die Benutzeroberfläche eine neue Chat-Sitzung starten, indem sie das Modell GPT-OSS-20B auswählen. Der Benutzer sollte den Befehl „Erklären Sie die wichtigsten Tendencies in der Forschung zu erneuerbaren Energien“ eingeben, um das Modell zu starten. Das 20B-Modell reagiert innerhalb weniger Sekunden auf den Benutzer. Das Modell openai/gpt-oss-120b bietet eine bessere Leistung, wenn Benutzer Zugriff auf eine leistungsstarke GPU haben.
• Einstellungen optimieren (non-obligatory): Benutzer können Temperatur- und Probenahmeeinstellungen über die Chat-Schnittstelle oder die CLI von LM Studio ändern. Das Modell liefert genauere Ergebnisse bei niedrigeren Temperatureinstellungen im Bereich von 0,2 bis 0,5. Das Modell generiert kreativen Output durch höhere Temperatureinstellungen, die bei 0,7 beginnen. Die von Ihnen gemachten Angaben sind für Ihre aktuellen Anforderungen nicht erforderlich.

Nachdem Sie diese fünf Schritte abgeschlossen haben, können Sie LM Studio erfolgreich mit seinem betriebsbereiten lokalen LLM-System ausführen. Mit dem System können Sie verschiedene Funktionen durch Dokumentzusammenfassungen sowie Aktivitäten zur Beantwortung von Fragen und zur Ideenfindung testen. Ihr System speichert alle von Ihnen durchgeführten Chat-Sitzungen.

Praktische Aufgabe 1: Erstellen eines technischen Forschungsberichts

Sie müssen etwas über ein neues Thema lernen, nämlich multimodale Abrufsysteme, damit Sie organisierte Notizen erstellen können, die Sie später verwenden können. Das Ziel des Projekts besteht darin, LM Studio für Forschungszwecke zu nutzen und gleichzeitig NotebookLM zum Erstellen organisierter Materialien zu verwenden.

Schritt-für-Schritt-Workflow

Schritt 1: Themenerkundung in LM Studio

Fordern Sie Ihr lokales Modell auf:

Clarify multimodal retrieval techniques together with: 
• structure 
• challenges 
• analysis metrics 
• actual world purposes 
Hold the response technical

Befolgen Sie anschließend die verfeinerten Eingabeaufforderungen:

Present implementation issues for manufacturing techniques 
Examine vector-based vs hybrid retrieval approaches

Schritt 2: Strukturieren Sie die Agentenantwort

Create structured markdown notes from this dialogue 
Embody headings and bullet factors

Schritt 3: In NotebookLM importieren

Verwenden Sie die von LMStudio bereitgestellte Antwort, kopieren Sie die Ausgabe oder exportieren Sie das Dokument nach NotebookLM.

Schritt 4: Verstärkungslernen

Nutzen Sie die NotebookLM-Funktionen:

• Lernkarten erstellen
• Quiz erstellen
• Studienführer erstellen

Praktische Aufgabe 2: Datensatzverständnis und Interviewvorbereitung

In dieser Aufgabe bereiten wir uns auf Diskussionen und Interviews zu technischen und domänenbezogenen Kenntnissen vor, indem wir uns ein umfassendes Verständnis des Datensatzes/der Domäne aneignen.

Schritt 1: Verwenden Sie LM Studio, um Domänenfragen zu erstellen

Act as a senior ML interviewer, create troublesome stage conceptual questions, with the understanding within the following areas: 
• Characteristic engineering 
• Mannequin bias 
• Analysis metrics

Schritt 2: Fragen in NotebookLM importieren

Integrieren Sie den generierten Fragensatz in:

• Skript
• Recherchieren Sie PDFs
• Dokumentation

Schritt 3: Verwenden Sie NotebookLM, um zu üben, anhand der oben genannten Materialien kontextbezogene Antworten auf Ihre Fragen zu geben.

Auf diese Weise können Sie genaue Antworten auf der Grundlage der verwendeten Materialien anstelle allgemeiner, von der KI generierter Antworten geben.

Schritt 4: Bewerten Sie Ihre Leistung mit der Quiz-Generierung von NotebookLM, um Testbedingungen zu emulieren.

Schritt 5: Erstellen Sie ein Foliendeck, um das Verständnis zu erleichtern.

Abschluss

Durch die Kombination von Google NotebookLM und LM Studio entsteht ein robuster Forschungsprozess, den Forscher auf ihren eigenen Systemen implementieren können. Benutzer beginnen mit der Inhaltserstellung über LM Studio, bevor sie ihre Arbeit auf NotebookLM übertragen, das zitierbasierte Zusammenfassungen und lehrreiche Frage- und Antwortsitzungen bietet.

Der Ansatz nutzt die beiden Instruments durch ihre unterschiedlichen Fähigkeiten, zu denen die flexiblen und privaten Funktionen von LM Studio und das pädagogische Framework von NotebookLM gehören. Ihre Arbeitseffizienz und Kontrolle über Ihre Aufgaben profitieren von der Kombination aus Cloud- und lokalen KI-Systemen. Viel Spaß beim Recherchieren!

Häufig gestellte Fragen

Knowledge Science Trainee bei Analytics Vidhya
Derzeit arbeite ich als Knowledge Science Trainee bei Analytics Vidhya, wo ich mich auf die Entwicklung datengesteuerter Lösungen und die Anwendung von KI/ML-Techniken zur Lösung realer Geschäftsprobleme konzentriere. Meine Arbeit ermöglicht es mir, fortschrittliche Analysen, maschinelles Lernen und KI-Anwendungen zu erforschen, die es Unternehmen ermöglichen, intelligentere, evidenzbasierte Entscheidungen zu treffen.
Mit einem starken Fundament in den Bereichen Informatik, Softwareentwicklung und Datenanalyse ist es mir eine Leidenschaft, KI zu nutzen, um wirkungsvolle, skalierbare Lösungen zu schaffen, die die Lücke zwischen Technologie und Geschäft schließen.
Du kannst mich auch erreichen unter (e-mail protected)