Muscle-Mem

Muscle-Mem ist ein Open-Source-Python-Tool, das auf GitHub gehostet und von pig-dot-dev entwickelt wird. Es zielt darauf ab, Verhaltens-Caching-Fähigkeiten für KI-Agenten zur Verfügung zu stellen, um große Sprachmodell-Aufrufe (LLM) in sich wiederholenden Aufgaben zu reduzieren und dadurch die Laufzeitgeschwindigkeit zu erhöhen, die Variabilität zu reduzieren und Kosten zu sparen. Muscle-Mem verwendet zwischengespeicherte Verhaltensweisen direkt wieder, wenn die gleiche Aufgabe angetroffen wird, indem es die Werkzeug-Aufrufmuster des KI-Agenten protokolliert und die Logik des Agenten nur aufruft, wenn ein neues Szenario erkannt wird. Sein Kernmechanismus ist die Cache-Validierung, die anhand von Umgebungsmerkmalen feststellt, ob eine Wiederverwendung von Caches sicher ist. Dieses Tool ist für Entwickler geeignet, die automatisierte Aufgaben optimieren müssen, insbesondere bei sich stark wiederholenden Arbeitsabläufen. Die offizielle Dokumentation und der Beispielcode sind übersichtlich, das Feedback der Community ist positiv, und es ist für Python-Entwickler und KI-Automatisierung geeignet.

Funktionsliste

• Verhaltensbasierte ZwischenspeicherungAufzeichnung der Werkzeugaufrufmuster des KI-Agenten und Zwischenspeicherung des Verhaltens zur Wiederverwendung.
• Cache-ValidierungCaching: Sicherstellen, dass das Caching-Verhalten in einem bestimmten Kontext durch Pre- und Post-Check-Mechanismen sicher ist.
• Werkzeug-DekorateurUnterstützung für die Verwendung von @engine.tool Decorator fügt dem Tool Caching-Funktionen hinzu.
• UmweltbewusstseinCache-Treffer (Cache-Hit) oder -Fehlversuche (Cache-Miss) anhand von Umgebungsmerkmalen bestimmen.
• Flexible IntegrationErmöglicht es Entwicklern, die Proxy-Logik anzupassen und sie in die Muscle-Mem-Engine einzubinden.
• Effiziente DurchführungReduzierung der Aufrufe von großen Sprachmodellen und Verbesserung der Ausführungsgeschwindigkeit von Aufgaben.

Hilfe verwenden

Einbauverfahren

Muscle-Mem ist eine Python-Bibliothek mit einem einfachen Installationsprozess. Hier sind die detaillierten Schritte:

1. Vorbereitung der Umwelt
   Stellen Sie sicher, dass Sie Python 3.7 oder höher auf Ihrem System installiert haben. Dies kann mit dem folgenden Befehl überprüft werden:

   python --version
   

   Virtuelle Umgebungen werden empfohlen, um z. B. Abhängigkeitskonflikte zu vermeiden:

   python -m venv venv
   source venv/bin/activate  # Linux/Mac
   venv\Scripts\activate     # Windows
   

2. Klonen eines Lagers oder einer Anlage
   Muscle-Mem wird derzeit über ein GitHub-Repository verteilt. Klonen Sie das Repository lokal:

   git clone https://github.com/pig-dot-dev/muscle-mem.git
   cd muscle-mem
   

   Installieren Sie dann die Abhängigkeiten:

   pip install -r requirements.txt
   

   Wenn das Repository Folgendes bietet setup.py, das mit dem folgenden Befehl installiert werden kann:

   pip install .
   

3. Überprüfen der Installation
   Sobald die Installation abgeschlossen ist, importieren Sie das Muscle-Mem-Modul und überprüfen Sie es auf seine Richtigkeit:

   from muscle_mem import Engine
   print(Engine())
   

   Wenn keine Fehler gemeldet werden, war die Installation erfolgreich.

Grundlegende Verwendung

Das Herzstück von Muscle-Mem sind Engine Klasse, die zur Verwaltung der Caching-Logik von Agenten und Tools verwendet wird. Im Folgenden werden die einzelnen Schritte zur Verwendung von Muscle-Mem beschrieben:

1. Initialisierung des Motors
   Erstellen einer Engine Beispiel:

   from muscle_mem import Engine
   engine = Engine()
   

2. Tools definieren und Caching hinzufügen
   ausnutzen @engine.tool Der Dekorator definiert die instrumentelle Funktion und übergibt die pre_check vielleicht post_check Fügen Sie eine Cache-Validierung hinzu. Definieren Sie zum Beispiel eine einfache hello Funktion:

   from dataclasses import dataclass
   import time
   from muscle_mem import Check
   # 定义环境特征的数据结构
   @dataclass
   class T:
   name: str
   time: float
   # 捕获环境特征
   def capture(name: str) -> T:
   now = time.time()
   return T(name=name, time=now)
   # 比较环境特征，验证缓存有效性
   def compare(current: T, candidate: T) -> bool:
   diff = current.time - candidate.time
   return diff <= 1  # 缓存1秒内有效
   # 定义工具并添加缓存检查
   @engine.tool(pre_check=Check(capture, compare))
   def hello(name: str):
   time.sleep(0.1)
   print(f"hello {name}")
   

3. Laufende Agenten
   Definieren Sie eine Proxy-Funktion und registrieren Sie sie bei der Engine. Beispiel:

   def agent(name: str):
   for i in range(9):
   hello(name + " + " + str(i))
   engine.set_agent(agent)
   

4. Ausführen der Aufgabe und Prüfen des Cache
   Die Aufrufmaschine führt den Proxy aus und prüft auf Cache-Treffer:

   cache_hit = engine("erik")  # 首次运行，缓存未命中
   print(cache_hit)  # False
   cache_hit = engine("erik")  # 再次运行，缓存命中
   print(cache_hit)  # True
   time.sleep(3)  # 等待缓存失效
   cache_hit = engine("erik")  # 缓存失效，重新运行
   print(cache_hit)  # False
   

Featured Function Bedienung

Mechanismus zur Cache-Validierung

Das Hauptmerkmal von Muscle-Mem ist die Cache-Validierung, die durch die Check Implementierung der Klasse. Der Entwickler muss zwei Funktionen definieren:

• captureErfassen der aktuellen Umgebungsmerkmale wie Zeit, Eingangsparameter usw.
• compareVergleichen Sie die aktuelle Umgebung mit der gecachten Umgebung, um festzustellen, ob der Cache wiederverwendet werden kann.

Im obigen Beispiel ist diecapture Aufzeichnung der Zeit und der Parameter des Anrufs.compare Prüfen Sie, ob die Zeitdifferenz innerhalb von 1 Sekunde liegt. Dieser Mechanismus gewährleistet die Sicherheit des Zwischenspeichers und verhindert ein Multiplexing-Verhalten in unangemessenen Szenarien.

Wiederverwendung von Werkzeugen

Muscle-Mem ermöglicht das Hinzufügen von Cache-Unterstützung für mehrere Tools. So kann zum Beispiel eine separate Cache-Validierungslogik für Tools wie Dateioperationen, API-Aufrufe usw. definiert werden. Der Entwickler schreibt einfach eine entsprechende capture im Gesang antworten compare Funktion mit der @engine.tool Dekorativer Einband.

Erweiterte Nutzung

1. Multi-Tool-Verwaltung
   Wenn Ihr Agent mehrere Tools aufrufen muss, können Sie für jedes Tool eine eigene Cache-Validierung definieren. Beispiel:

   @engine.tool(pre_check=Check(capture_file, compare_file))
   def read_file(path: str):
   with open(path, 'r') as f:
   return f.read()
   @engine.tool(pre_check=Check(capture_api, compare_api))
   def call_api(url: str):
   import requests
   return requests.get(url).text
   

2. Dynamische Caching-Politik
   Die Entwickler können die Cache-Richtlinie entsprechend den Aufgabenanforderungen anpassen. Zum Beispiel kann die Gültigkeitsdauer des Caches verlängert oder dynamisch auf der Grundlage von Eingabeparametern angepasst werden. compare Logik.
3. Debugging-Cache
   Muscle-Mem unterstützt die Überprüfung von Cache-Treffern, Entwickler können protokollieren oder einen Rückgabewert angeben, um festzustellen, ob der Cache in Kraft ist, um die Fehlersuche und Optimierung zu erleichtern.

caveat

• sicher capture im Gesang antworten compare Die Funktionslogik muss korrekt sein, sonst kann es zu einem Missbrauch des Cache kommen.
• Zwischengespeicherte Daten werden im Speicher abgelegt und sind für kurzfristige Aufgaben geeignet. Für langfristige Aufgaben wird empfohlen, Muscle-Mem zu erweitern, um eine dauerhafte Speicherung zu unterstützen.
• Werkzeugfunktionen sollten so einfach wie möglich gehalten werden, um zu vermeiden, dass komplexe Logik die Effizienz des Caching beeinträchtigt.

Anwendungsszenario

1. Automatisierung Skript-Optimierung
   Muscle-Mem eignet sich für die Optimierung von Automatisierungsskripten, die wiederholt ausgeführt werden. Zum Beispiel muss ein Agent in einer Datenverarbeitungspipeline dieselben Vorverarbeitungsfunktionen mehrmals aufrufen. Durch die Zwischenspeicherung der Ausführungsergebnisse dieser Funktionen mit Muscle-Mem kann die Laufzeit erheblich reduziert werden.
2. AI-Agent Aufgabenbeschleunigung
   Bei KI-gesteuerten Automatisierungsaufgaben, wie z. B. Web-Crawlern oder Kundendienst-Bots, zwischenspeichert Muscle-Mem gängige Logik zur Verarbeitung von Benutzeranfragen, wodurch die Aufrufe großer Sprachmodelle reduziert und die Antwortzeiten verbessert werden.
3. Entwicklung Testumgebung
   Beim Testen von KI-Agenten können Entwickler Muscle-Mem verwenden, um die Ausführungsergebnisse von Testfällen zwischenzuspeichern, wodurch die wiederholte Ausführung zeitaufwändiger Aufgaben vermieden und die Entwicklungseffizienz verbessert wird.

QA

1. Welche Programmiersprachen werden von Muscle-Mem unterstützt?
   Muscle-Mem ist eine Python-Bibliothek, die derzeit nur die Python-Entwicklungsumgebung unterstützt. Sie kann in Zukunft auf andere Sprachen erweitert werden, aber es gibt keine offiziellen Pläne dafür.
2. Wie kann ich meinen Cache sichern?
   Muscle-Mem Verabschiedet Check Klasse capture im Gesang antworten compare Funktionen validieren Umgebungsmerkmale. Die Entwickler müssen eine angemessene Validierungslogik auf der Grundlage der Funktionen des Tools entwerfen, um sicherzustellen, dass der Cache nur in sicheren Szenarien wiederverwendet wird.
3. Wo werden die Daten im Cache gespeichert?
   Standardmäßig werden die zwischengespeicherten Daten im Speicher abgelegt. Wenn eine dauerhafte Speicherung erforderlich ist, können Entwickler Muscle-Mem erweitern, um den Cache in einer Datenbank oder einem Dateisystem zu speichern.
4. Unterstützt es Multithreading oder asynchrone Operationen?
   Die offizielle Dokumentation von Muscle-Mem erwähnt nicht ausdrücklich die Unterstützung von Multithreading, aber das Design basiert auf Python und könnte theoretisch erweitert werden, um asynchrone Operationen durch asynchrone Frameworks wie asyncio zu unterstützen.