Artikel über Techniken, die ich bei der Verwendung von Claude Code anwende, um das Beste daraus zu machen. Ein Thema, mit dem ich mich jedoch weniger beschäftigt habe, ist die Frage, wie ich meine Claude-Code-Nutzung im Allgemeinen verbessern kann. Wie optimiere ich die Artwork und Weise, wie ich mit meinen Claude Code-Instanzen interagiere und wie mein Claude Code in den Code-Repositorys funktioniert, die ich aktualisiere?

In diesem Artikel möchte ich hervorheben, wie ich die Artwork und Weise, wie ich mit Claude Code interagiere und wie mein Claude Code funktioniert, kontinuierlich aktualisiere, wodurch ich und mein Coding-Agent mit der Zeit immer effektiver werden.

Das Konzept des kontinuierlichen Lernens ist unglaublich wirkungsvoll, denn wenn Sie sich jeden Tag nur um ein paar Prozent verbessern können, wird der kumulative Effekt über Wochen und Monate hinweg enorm sein. Sie können wesentlich effizienter arbeiten als nur mit der Standardversion von Claude Code oder einem anderen Codierungsagenten.

Warum kontinuierliches Lernen betreiben?

Ich versuche immer zu erläutern, warum ein Thema wichtig ist, warum Sie sich darum kümmern sollten und wie es Ihnen helfen kann. Der Grund, warum Sie kontinuierlich lernen sollten, ist einfach: Wenn Sie nur die Standardversion von Claude Code, Codex oder einem anderen Codierungsagenten verwenden, verlieren Sie etwas. Natürlich sind diese Modelle unglaublich leistungsstark, und wenn man sie mit denen von vor ein paar Jahren vergleicht, kann man immer noch um ein Vielfaches effizienter sein als früher.

Das spielt jedoch keine Rolle. Was wirklich zählt, ist, dass Sie durch die Anwendung kontinuierlichen Lernens erneut einen enormen Effizienzschub erzielen.

In diesem Artikel beschreibe ich eine sehr einfache Technik, mit der ich dafür sorge, dass sich mein Claude Code jeden Tag verbessert. Außerdem gebe ich Ihnen einen Einblick, wie ich versuche, meine eigenen Interaktionen mit Claude Code zu optimieren, um die Interaktion zwischen menschlichen Programmieragenten so effektiv wie möglich zu gestalten.

Claude Code dazu bringen, von sich selbst zu lernen

Ich beginne mit der Erläuterung der einfachen Technik, die Sie jetzt anwenden können und die mit ziemlicher Sicherheit die Leistung Ihres Claude Code verbessern wird.

Sie können in Claude Code einfach einen Talent erstellen, der etwa so aussieht:

Evaluation my final interactions with Claude Code from the final 24 hours. 
Search for any issues that I encountered, issues that weren't working 
effectively, and pointless device calling. Search for widespread errors 
Claude Code was doing and different issues that may be optimized. 
Look completely via all conversations and make a plan for the way we 
can optimize our circulation sooner or later, each inside every repository and 
cross-repositories. Additionally search for insights that may be helpful for the 
coding agent to know beforehand, each earlier than coming into a repository and 
when working in a number of repositories on the similar time. 

Nehmen wir an, wir nennen diese Fertigkeitsüberprüfung „Vergangene Leistung“. Was Sie nun tun sollten, ist einen Cronjob einzurichten, um diesen Talent jede Nacht um 2 Uhr morgens oder zu einem Zeitpunkt, an dem Sie wissen, dass Sie nicht aktiv mit Ihren Agenten interagieren, auszulösen.

Wenn Sie diesen Talent implementieren und ausführen, wird Claude alle Gespräche durchgehen, die Sie in den letzten 24 Stunden geführt haben. Ich werde mir die Threads ansehen. Wir werden sehen, wo Sie mit Claude Code steckengeblieben sind (d. h. wo Sie mehr Zeit aufgewendet haben, als Sie sollten), und wir werden sehen, wo Claude Code steckengeblieben ist, weil er falsche Toolaufrufe vorgenommen hat, falsche Annahmen vorgenommen hat oder wo einfach nicht der Kontext vorhanden struggle, den er brauchte, um die Aufgabe effektiv auszuführen.

Anschließend wird ein Plan erstellt, wie diese Dinge in Zukunft vermieden werden können und Claude Code in den meisten Fällen effektiver funktioniert. Dadurch werden Änderungen umgesetzt wie:

• Hinzufügen weiterer Informationen zu Brokers.md oder ähnlichen generischen Markdown-Dateien
• Erstellen spezifischer Fähigkeiten, die der Agent entweder bei Bedarf laden oder bei Bedarf ausführen kann, wenn er bestimmte Aufgaben erledigt
• Implementierung spezifischer Skripte oder Instruments, wie Pre-Commit-Hooks, Testskripte und Ähnliches, um zu verhindern, dass Fehler erneut passieren

Das Beste an der Einrichtung eines Cron-Jobs zur täglichen Ausführung dieses Abilities ist, dass Sie überhaupt nicht mit Agenten interagieren müssen. Es wird in der Lage sein, sich auf effiziente Weise selbst zu reflektieren, Ineffizienzen zu entdecken, sie zu optimieren und so Claude Code im Laufe der Zeit zu verbessern. Das Beste daran ist, dass Claude Code an Ihre spezifischen Anwendungsfälle angepasst werden kann. Möglicherweise haben Sie einen bestimmten Tech-Stack oder bestimmte Vorlieben, wenn Sie in Repositories arbeiten. Wenn Sie diesen Talent ausführen, werden diese Präferenzen ermittelt und optimiert, um sie so effizient wie möglich zu gestalten.

Indem ich diesen Cron-Job einfach jede Nacht ausführe, habe ich enorme Effizienzsteigerungen erzielt, da meine Codierungsagenten viel leistungsfähiger geworden sind als früher, einfach weil sie weniger Fehler machen. Sie wissen besser, wie man Dinge richtig angeht, und insgesamt folgen sie meinen Vorlieben besser.

Verbesserung der menschlichen Interaktion mit Codierungsagenten

Ein weiterer, komplizierter zu optimierender Aspekt ist die menschliche Interaktion mit Codierungsagenten. Ich verbringe viel Zeit damit, darüber nachzudenken und nachzudenken, wie ich am effektivsten mit meinen Agenten kommunizieren kann, damit sie den von mir gewünschten Code so schnell und effizient wie möglich implementieren.

Dies ist eindeutig noch kein gelöstes Drawback, da immer noch viele verschiedene Instruments und Plattformen auf den Markt kommen, um die Codierung von Agenten und die Interaktion mit ihnen einfacher, besser und effizienter zu machen. In diesem Abschnitt werde ich einige meiner Überlegungen zur menschlichen Interaktion mit Codierungsagenten behandeln und wie ich versuche, sie selbst zu optimieren.

Beachten Sie, dass die Techniken, die ich behandeln werde, natürlich für meine eigenen Arbeitsabläufe optimiert und abgestimmt sind. Ich empfehle Ihnen dringend, sie zu lesen und sich darüber zu informieren und darüber nachzudenken, wie sich dies auf Ihre eigenen Arbeitsabläufe anwenden lässt.

Führen Sie mehr als 7 Agenten gleichzeitig aus

Ich betreibe oft viele Agenten gleichzeitig, einfach weil ich viele Aufgaben zu erledigen habe und parallel daran arbeiten kann. Natürlich gibt es externe Faktoren, die darüber entscheiden, ob es für mich möglich oder überhaupt related ist, so viele Agenten gleichzeitig zu betreiben. Wenn die State of affairs es zulässt und es aus Effizienzgründen sinnvoll ist, werde ich natürlich so viele Agenten wie möglich parallel betreiben.

Allerdings habe ich festgestellt, dass ich die Kontrolle über alle meine Agenten verliere, wenn ich anfange, mehr als sieben Agenten gleichzeitig zu erreichen. Ich bin nicht in der Lage, den Kontext zwischen ihnen effektiv zu wechseln, mit den Aktivitäten der einzelnen Agenten Schritt zu halten und dem Agenten effektiv zu antworten, wenn er mir Fragen stellt.

Ich habe viele verschiedene Instruments und Plattformen ausprobiert, um diese Interaktion effizienter zu gestalten. Ich verwende derzeit Warp, wo ich geteilte Bereiche für jede Registerkarte verwende, wenn ich mit parallelen Agenten innerhalb eines Repositorys arbeite, und neue Registerkarten für jedes andere Repository erstelle, an dem ich arbeite. Das funktioniert relativ intestine, auch wenn ich, wie bereits erwähnt, bei der gleichzeitigen Ausführung von mehr als sieben Agenten nicht weiterkomme.

Ich habe auch IDE-basiertere Ansätze wie Conductor oder Omnara ausprobiert, aber ich habe nicht das Gefühl, dass sie mir Produktivitätssteigerungen gegenüber dem bieten, was Warp mir bieten kann.

Mein Fazit aus diesem Abschnitt sind einige Techniken, mit denen Sie so viele Agenten wie möglich gleichzeitig ausführen können. Zunächst einmal muss die State of affairs es zulassen. Es muss so sein, dass Sie über genügend Aufgaben verfügen, die alle parallel ausgeführt werden können, und dass Sie den Agenten so lange laufen lassen können, dass Sie nicht ständig unterbrochen werden. Schritt eins ist einfach, dass die Aufgabe oder Aufgaben, die Sie erledigen, dies zulassen müssen.

Zweitens ist eine Zusammenfassung eine sehr wirkungsvolle Sache, wenn man mit vielen Agenten parallel arbeitet. Claude Code hat begonnen, am Ende des Chats eine Zusammenfassung bereitzustellen, die unglaublich aussagekräftig ist. Es gibt Ihnen einen superkurzen Überblick darüber, was Sie in diesem Chat tun, sodass Sie sich schnell über den Kontext informieren können, wenn Sie erneut mit einem Agenten interagieren müssen. Ich empfehle Ihnen dringend, Zusammenfassungen zu aktivieren und aktiv zu nutzen, wenn Sie den Kontext eines bestimmten Threads nachlesen möchten.

Abschließend möchte ich in diesem Abschnitt auch darauf hinweisen, dass Claude Code heute, zum Zeitpunkt des Schreibens dieses Artikels, gerade eine veröffentlicht hat Agentenansicht in Claude Code. Dies ist eine Ansicht, die es einfacher machen soll, den Überblick über alle Ihre Agenten auf einmal zu behalten. Ich habe es selbst noch nicht ausprobiert, aber es scheint genau das Drawback zu lösen, das ich in diesem Abschnitt beschreibe. Ich werde es auf jeden Fall ausprobieren und in Zukunft einen Artikel darüber schreiben.

Lassen Sie sich vom Agenten Fragen stellen, nicht umgekehrt

Dieser Unterabschnitt ist interessant, da die übliche Artwork der Interaktion mit KI-Modellen, zumindest am Anfang, darin bestand, ihnen Fragen zu stellen und sie prägnant antworten zu lassen. Dies ändert sich jedoch völlig, sobald Sie anfangen, sich mit lang laufenden Codesitzungen zu befassen. Sie möchten ihm keine Fragen mehr stellen, Sie möchten, dass er so lange wie möglich möglichst selbstständig arbeitet und erst aufhört, wenn er Ihnen Fragen stellen muss.

Daher empfehle ich Ihnen, dies in die Eingabeaufforderungen Ihrer Programmieragenten einzugeben. Sie möchten, dass sie möglichst lange und unabhängig laufen und erst dann mit der Implementierung aufhören, wenn dem Benutzer eine Frage gestellt werden muss. Dies hängt natürlich auch stark mit einem anderen Artikel zusammen, den ich geschrieben habe, in dem es darum geht, wie man Claude Code seine eigene Arbeit validieren lässt. Damit der Agent lange läuft, müssen Sie ihm eine Possibility oder Möglichkeit geben, seine eigene Arbeit zu überprüfen, was ich in einem anderen Artikel von In the direction of Knowledge Science behandelt habe. Schauen Sie es sich unten an:

Wie man Claude-Code dazu bringt, seine eigene Arbeit zu validieren

Abschluss

In diesem Artikel habe ich beschrieben, wie ich meine Claude Code-Instanz kontinuierlich verbessere, indem ich Claude Code jede Nacht durch Selbstreflexion selbst verbesserungsfähig mache und die menschliche Interaktion mit Claude Code und anderen Programmieragenten verbessere. Ich glaube, dass Sie als Ingenieur versuchen sollten, diese beiden Dinge zu optimieren, um Ihre Codierung effektiver zu gestalten. Als Ingenieur sollten Sie immer auf den nächsten Engpass achten: Was Sie am meisten ausbremst und den größten Produktivitätsschub ermöglicht. Für mich entdeckte ich, dass dies Folgendes struggle:

1. Claude Code wiederholt Fehler, die im ersten Abschnitt dieses Artikels behoben werden
2. Die menschliche Interaktion mit Claude Code, die ich im zweiten Abschnitt dieses Artikels behandelt habe

Ich fordere Sie dringend auf, ständig nach solchen Engpässen zu suchen und zu versuchen, sie so schnell wie möglich zu beseitigen, um Ihre Codierungsbemühungen so produktiv wie möglich zu gestalten.

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

In diesem Tutorial untersuchen wir, wie man Agentensysteme aufbaut, die über eine einzelne Interaktion hinausdenken, indem Speicher als Kernfunktion genutzt wird. Wir gehen durch, wie wir das episodische Gedächtnis zum Speichern von Erfahrungen und das semantische Gedächtnis zum Erfassen langfristiger Muster entwerfen, sodass der Agent sein Verhalten über mehrere Sitzungen hinweg weiterentwickeln kann. Während wir planen, handeln, überarbeiten und reflektieren, beobachten wir, wie sich der Agent allmählich an die Präferenzen des Benutzers anpasst und autonomer wird. Am Ende verstehen wir, wie gedächtnisgesteuertes Denken uns hilft, Agenten zu schaffen, die sich bei jeder Interaktion kontextbezogener, konsistenter und intelligenter anfühlen. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

import numpy as np
from collections import defaultdict
import json
from datetime import datetime
import pickle


class EpisodicMemory:
   def __init__(self, capability=100):
       self.capability = capability
       self.episodes = ()
      
   def retailer(self, state, motion, consequence, timestamp=None):
       if timestamp is None:
           timestamp = datetime.now().isoformat()
       episode = {
           'state': state,
           'motion': motion,
           'consequence': consequence,
           'timestamp': timestamp,
           'embedding': self._embed(state, motion, consequence)
       }
       self.episodes.append(episode)
       if len(self.episodes) > self.capability:
           self.episodes.pop(0)
  
   def _embed(self, state, motion, consequence):
       textual content = f"{state} {motion} {consequence}".decrease()
       return hash(textual content) % 10000
  
   def retrieve_similar(self, query_state, ok=3):
       if not self.episodes:
           return ()
       query_emb = self._embed(query_state, "", "")
       scores = ((abs(ep('embedding') - query_emb), ep) for ep in self.episodes)
       scores.kind(key=lambda x: x(0))
       return (ep for _, ep in scores(:ok))
  
   def get_recent(self, n=5):
       return self.episodes(-n:)


class SemanticMemory:
   def __init__(self):
       self.preferences = defaultdict(float)
       self.patterns = defaultdict(checklist)
       self.success_rates = defaultdict(lambda: {'success': 0, 'whole': 0})
      
   def update_preference(self, key, worth, weight=1.0):
       self.preferences(key) = 0.9 * self.preferences(key) + 0.1 * weight * worth
  
   def record_pattern(self, context, motion, success):
       pattern_key = f"{context}_{motion}"
       self.patterns(context).append((motion, success))
       self.success_rates(pattern_key)('whole') += 1
       if success:
           self.success_rates(pattern_key)('success') += 1
  
   def get_best_action(self, context):
       if context not in self.patterns:
           return None
       action_scores = defaultdict(lambda: {'success': 0, 'whole': 0})
       for motion, success in self.patterns(context):
           action_scores(motion)('whole') += 1
           if success:
               action_scores(motion)('success') += 1
       best_action = max(action_scores.gadgets(), key=lambda x: x(1)('success') / max(x(1)('whole'), 1))
       return best_action(0) if best_action(1)('whole') > 0 else None
  
   def get_preference(self, key):
       return self.preferences.get(key, 0.0)

Wir definieren die Kernspeicherstrukturen, auf die sich unser Agent verlässt. Wir bauen ein episodisches Gedächtnis auf, um spezifische Erfahrungen zu erfassen, und ein semantisches Gedächtnis, um Muster im Laufe der Zeit zu verallgemeinern. Indem wir diese Grundlagen schaffen, bereiten wir den Agenten darauf vor, aus Interaktionen zu lernen, so wie es Menschen tun. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

class MemoryAgent:
   def __init__(self):
       self.episodic_memory = EpisodicMemory(capability=50)
       self.semantic_memory = SemanticMemory()
       self.current_plan = ()
       self.session_count = 0
      
   def understand(self, user_input):
       user_input = user_input.decrease()
       if any(phrase in user_input for phrase in ('suggest', 'recommend', 'what ought to')):
           intent="advice"
       elif any(phrase in user_input for phrase in ('bear in mind', 'favor', 'like', 'favourite')):
           intent="preference_update"
       elif any(phrase in user_input for phrase in ('do', 'full', 'end', 'activity')):
           intent="task_execution"
       else:
           intent="dialog"
       return {'intent': intent, 'uncooked': user_input}
  
   def plan(self, state):
       intent = state('intent')
       user_input = state('uncooked')
       similar_episodes = self.episodic_memory.retrieve_similar(user_input, ok=3)
       plan = ()
       if intent == 'advice':
           genre_prefs = {ok: v for ok, v in self.semantic_memory.preferences.gadgets() if 'genre_' in ok}
           if genre_prefs:
               best_genre = max(genre_prefs.gadgets(), key=lambda x: x(1))(0)
               plan.append(('suggest', best_genre.exchange('genre_', '')))
           else:
               plan.append(('suggest', 'normal'))
       elif intent == 'preference_update':
           genres = ('sci-fi', 'fantasy', 'thriller', 'romance', 'thriller')
           detected_genre = subsequent((g for g in genres if g in user_input), None)
           if detected_genre:
               plan.append(('update_preference', detected_genre))
       elif intent == 'task_execution':
           best_action = self.semantic_memory.get_best_action('activity')
           if best_action:
               plan.append(('execute', best_action))
           else:
               plan.append(('execute', 'default'))
       self.current_plan = plan
       return plan

Wir konstruieren die Wahrnehmungs- und Planungssysteme des Agenten. Wir verarbeiten die Eingaben des Benutzers, erkennen Absichten und erstellen Pläne, indem wir die zuvor gebildeten Erinnerungen nutzen. Wir beginnen zu gestalten, wie der Agent seine nächsten Aktionen begründet und entscheidet. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

 def act(self, motion):
       action_type, param = motion
       if action_type == 'suggest':
           if param == 'normal':
               return f"Let me be taught your preferences first! What genres do you get pleasure from?"
           return f"Based mostly in your preferences, I like to recommend exploring {param}!"
       elif action_type == 'update_preference':
           self.semantic_memory.update_preference(f'genre_{param}', 1.0, weight=1.0)
           return f"Received it! I am going to bear in mind you get pleasure from {param}."
       elif action_type == 'execute':
           return f"Executing activity with technique: {param}"
       return "Motion accomplished"
  
   def revise_plan(self, suggestions):
       if 'no' in suggestions.decrease() or 'incorrect' in suggestions.decrease():
           if self.current_plan:
               action_type, param = self.current_plan(0)
               if action_type == 'suggest':
                   genre_prefs = sorted(
                       ((ok, v) for ok, v in self.semantic_memory.preferences.gadgets() if 'genre_' in ok),
                       key=lambda x: x(1),
                       reverse=True
                   )
                   if len(genre_prefs) > 1:
                       new_genre = genre_prefs(1)(0).exchange('genre_', '')
                       self.current_plan = (('suggest', new_genre))
                       return True
       return False
  
   def replicate(self, state, motion, consequence, success):
       self.episodic_memory.retailer(state('uncooked'), str(motion), consequence)
       self.semantic_memory.record_pattern(state('intent'), str(motion), success)

Wir definieren, wie der Agent Aktionen ausführt, seine Entscheidungen revidiert, wenn das Suggestions den Erwartungen widerspricht, und wie er durch die Speicherung von Erfahrungen reflektiert. Wir verbessern kontinuierlich das Verhalten des Agenten, indem wir ihn aus jeder Runde lernen lassen. Durch diese Schleife machen wir das System anpassungsfähig und selbstkorrigierend. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

 def run_session(self, user_inputs):
       self.session_count += 1
       print(f"n{'='*60}")
       print(f"SESSION {self.session_count}")
       print(f"{'='*60}n")
       outcomes = ()
       for i, user_input in enumerate(user_inputs, 1):
           print(f"Flip {i}")
           print(f"Person: {user_input}")
           state = self.understand(user_input)
           plan = self.plan(state)
           if not plan:
               print("Agent: I am unsure what to do with that.n")
               proceed
           response = self.act(plan(0))
           print(f"Agent: {response}n")
           success="suggest" in plan(0)(0) or 'replace' in plan(0)(0)
           self.replicate(state, plan(0), response, success)
           outcomes.append({
               'flip': i,
               'enter': user_input,
               'intent': state('intent'),
               'motion': plan(0),
               'response': response
           })
       return outcomes

Wir simulieren reale Interaktionen, bei denen der Agent mehrere Benutzereingaben innerhalb einer einzigen Sitzung verarbeitet. Wir beobachten, wie sich der Zyklus Wahrnehmen → Planen → Handeln → Reflektieren immer wieder entfaltet. Während wir Sitzungen durchführen, sehen wir, wie der Agent nach und nach personalisierter und intelligenter wird. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

def evaluate_memory_usage(agent):
   print("n" + "="*60)
   print("MEMORY ANALYSIS")
   print("="*60 + "n")
   print(f"Episodic Reminiscence:")
   print(f"  Complete episodes saved: {len(agent.episodic_memory.episodes)}")
   if agent.episodic_memory.episodes:
       print(f"  Oldest episode: {agent.episodic_memory.episodes(0)('timestamp')}")
       print(f"  Newest episode: {agent.episodic_memory.episodes(-1)('timestamp')}")
   print(f"nSemantic Reminiscence:")
   print(f"  Discovered preferences: {len(agent.semantic_memory.preferences)}")
   for pref, worth in sorted(agent.semantic_memory.preferences.gadgets(), key=lambda x: x(1), reverse=True)(:5):
       print(f"    {pref}: {worth:.3f}")
   print(f"n  Motion patterns discovered: {len(agent.semantic_memory.patterns)}")
   print(f"n  Success charges by context-action:")
   for key, stats in checklist(agent.semantic_memory.success_rates.gadgets())(:5):
       if stats('whole') > 0:
           charge = stats('success') / stats('whole')
           print(f"    {key}: {charge:.2%} ({stats('success')}/{stats('whole')})")


def compare_sessions(results_history):
   print("n" + "="*60)
   print("CROSS-SESSION ANALYSIS")
   print("="*60 + "n")
   for i, ends in enumerate(results_history, 1):
       recommendation_quality = sum(1 for r in outcomes if 'preferences' in r('response').decrease())
       print(f"Session {i}:")
       print(f"  Turns: {len(outcomes)}")
       print(f"  Customized responses: {recommendation_quality}")

Wir analysieren, wie effektiv der Agent seine Erinnerungen nutzt. Wir überprüfen gespeicherte Episoden, erlernte Präferenzen und Erfolgsmuster, um zu bewerten, wie sich der Agent entwickelt. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

def run_demo():
   agent = MemoryAgent()
   print("n SCENARIO: Agent learns consumer preferences over a number of periods")
   session1_inputs = (
       "Hello, I am searching for one thing to learn",
       "I actually like sci-fi books",
       "Are you able to suggest one thing?",
   )
   results1 = agent.run_session(session1_inputs)
   session2_inputs = (
       "I am bored, what ought to I learn?",
       "Really, I additionally get pleasure from fantasy novels",
       "Give me a advice",
   )
   results2 = agent.run_session(session2_inputs)
   session3_inputs = (
       "What do you recommend for tonight?",
       "I am within the temper for thriller too",
       "Advocate one thing primarily based on what you recognize about me",
   )
   results3 = agent.run_session(session3_inputs)
   evaluate_memory_usage(agent)
   compare_sessions((results1, results2, results3))
   print("n" + "="*60)
   print("EPISODIC MEMORY RETRIEVAL TEST")
   print("="*60 + "n")
   question = "suggest sci-fi"
   comparable = agent.episodic_memory.retrieve_similar(question, ok=3)
   print(f"Question: '{question}'")
   print(f"Retrieved {len(comparable)} comparable episodes:n")
   for ep in comparable:
       print(f"  State: {ep('state')}")
       print(f"  Motion: {ep('motion')}")
       print(f"  Final result: {ep('consequence')(:50)}...")
       print()


if __name__ == "__main__":
   print("="*60)
   print("MEMORY & LONG-TERM AUTONOMY IN AGENTIC SYSTEMS")
   print("="*60)
   run_demo()
   print("n Tutorial full! Key takeaways:")
   print("  • Episodic reminiscence shops particular experiences")
   print("  • Semantic reminiscence generalizes patterns")
   print("  • Brokers enhance suggestions over periods")
   print("  • Reminiscence retrieval guides future choices")

Wir bringen alles zusammen, indem wir mehrere Sitzungen durchführen und den Speicherabruf testen. Wir beobachten, wie sich der Agent über Interaktionen hinweg verbessert und verfeinern Empfehlungen auf der Grundlage des gesammelten Wissens. Diese umfassende Demo veranschaulicht, wie sich aus den von uns entwickelten Speichersystemen auf natürliche Weise langfristige Autonomie ergibt.

Zusammenfassend erkennen wir, wie die Kombination aus episodischem und semantischem Gedächtnis es uns ermöglicht, Agenten zu entwickeln, die kontinuierlich lernen und im Laufe der Zeit immer bessere Entscheidungen treffen. Wir beobachten, wie der Agent Empfehlungen verfeinert, Pläne anpasst und vergangene Erfahrungen abruft, um seine Reaktionen Sitzung für Sitzung zu verbessern. Durch diese Mechanismen sehen wir, wie aus einfachen, aber effektiven Gedächtnisstrukturen langfristige Autonomie entsteht.

Schauen Sie sich das an VOLLSTÄNDIGE CODES hier. Schauen Sie sich gerne bei uns um GitHub-Seite für Tutorials, Codes und Notebooks. Sie können uns auch gerne weiter folgen Twitter und vergessen Sie nicht, bei uns mitzumachen 100.000+ ML SubReddit und Abonnieren Unser Publication. Warten! Bist du im Telegram? Jetzt können Sie uns auch per Telegram kontaktieren.

Asif Razzaq ist CEO von Marktechpost Media Inc.. Als visionärer Unternehmer und Ingenieur setzt sich Asif dafür ein, das Potenzial der künstlichen Intelligenz für das soziale Wohl zu nutzen. Sein jüngstes Unterfangen ist die Einführung einer Medienplattform für künstliche Intelligenz, Marktechpost, die sich durch eine ausführliche Berichterstattung über maschinelles Lernen und Deep-Studying-Nachrichten auszeichnet, die sowohl technisch fundiert als auch für ein breites Publikum leicht verständlich ist. Die Plattform verfügt über mehr als 2 Millionen monatliche Aufrufe, was ihre Beliebtheit beim Publikum verdeutlicht.

Folgen Sie MARKTECHPOST: Fügen Sie uns als bevorzugte Quelle bei Google hinzu.