autogen_ext.experimental.task_centric_memory#

class MemoryController(reset: bool, client: ChatCompletionClient, task_assignment_callback: Callable[[str], Awaitable[Tuple[str, str]]] | None = None, config: MemoryControllerConfig | None = None, logger: PageLogger | None = None)[Quelle]#

Basiert auf: object

(EXPERIMENTELL, FORSCHUNG LÄUFT)

Implementiert schnelles, speicherbasiertes Lernen und verwaltet den Informationsfluss zu und von einer Wissensdatenbank.

Parameter:

reset – True, um die Wissensdatenbank vor dem Start zu leeren.
client – Der intern zu verwendende Modell-Client.
task_assignment_callback – Ein optionaler Callback, der verwendet wird, um einem vom Aufrufer verwalteten Agenten eine Aufgabe zuzuweisen.
config –
Ein optionales Dictionary, mit dem die folgenden Werte überschrieben werden können
- generalize_task: Ob Aufgaben allgemeiner formuliert werden sollen.
- revise_generalized_task: Ob die verallgemeinerte Aufgabe kritisiert und dann neu geschrieben werden soll.
- generate_topics: Ob die Abfrage direkt auf Aufgaben basieren soll oder auf aus Aufgaben extrahierten Themen.
- validate_memos: Ob beim Abrufen von Notizen eine abschließende Validierungsstufe angewendet werden soll.
- max_memos_to_retrieve: Die maximale Anzahl von Notizen, die von retrieve_relevant_memos() zurückgegeben werden sollen.
- max_train_trials: Die maximale Anzahl von Lerniterationen, die beim Trainieren einer Aufgabe versucht werden sollen.
- max_test_trials: Die Gesamtzahl der Versuche, die beim Testen einer Aufgabe auf Fehler unternommen werden.
- MemoryBank: Ein Konfigurations-Dictionary, das an MemoryBank übergeben wird.
logger – Ein optionaler Logger. Wenn None, wird ein Standard-Logger erstellt.

Beispiel

Das Extra task-centric-memory muss zuerst installiert werden

pip install "autogen-ext[task-centric-memory]"

Der folgende Codeausschnitt zeigt, wie diese Klasse für die grundlegendste Speicherung und Abfrage von Notizen verwendet wird.

import asyncio
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_ext.experimental.task_centric_memory import MemoryController
from autogen_ext.experimental.task_centric_memory.utils import PageLogger


async def main() -> None:
    client = OpenAIChatCompletionClient(model="gpt-4o")
    logger = PageLogger(config={"level": "DEBUG", "path": "./pagelogs/quickstart"})  # Optional, but very useful.
    memory_controller = MemoryController(reset=True, client=client, logger=logger)

    # Add a few task-insight pairs as memories, where an insight can be any string that may help solve the task.
    await memory_controller.add_memo(task="What color do I like?", insight="Deep blue is my favorite color")
    await memory_controller.add_memo(task="What's another color I like?", insight="I really like cyan")
    await memory_controller.add_memo(task="What's my favorite food?", insight="Halibut is my favorite")

    # Retrieve memories for a new task that's related to only two of the stored memories.
    memos = await memory_controller.retrieve_relevant_memos(task="What colors do I like most?")
    print("{} memories retrieved".format(len(memos)))
    for memo in memos:
        print("- " + memo.insight)


asyncio.run(main())

reset_memory() → None[Quelle]#: Leert die Wissensdatenbank im RAM und auf der Festplatte.

async train_on_task(task: str, expected_answer: str) → None[Quelle]#: Weist dem Agenten wiederholt eine Aufgabe zu und versucht, aus Fehlern zu lernen, indem nützliche Erkenntnisse als Notizen erstellt werden.

async test_on_task(task: str, expected_answer: str, num_trials: int = 1) → Tuple[str, int, int][Quelle]#: Weist dem Agenten eine Aufgabe zu, zusammen mit allen relevanten, aus dem Speicher abgerufenen Notizen.

async add_memo(insight: str, task: None | str = None, index_on_both: bool = True) → None[Quelle]#: Fügt eine Erkenntnis zur Wissensdatenbank hinzu und verwendet die Aufgabe (falls angegeben) als Kontext.

async add_task_solution_pair_to_memory(task: str, solution: str) → None[Quelle]#: Fügt ein Aufgaben-Lösungs-Paar zur Wissensdatenbank hinzu, das später als kombinierte Erkenntnis abgerufen werden kann. Dies ist nützlich, wenn das Aufgaben-Lösungs-Paar ein Beispiel für die Lösung einer Aufgabe ist, die sich auf eine andere Aufgabe bezieht.

async retrieve_relevant_memos(task: str) → List[Memo][Quelle]#: Ruft Notizen aus dem Speicher ab, die für die Aufgabe relevant erscheinen.

async assign_task(task: str, use_memory: bool = True, should_await: bool = True) → str[Quelle]#: Weist über den task_assignment_callback eine Aufgabe einem Agenten zu, zusammen mit allen relevanten Notizen.

async consider_memo_storage(text: str) → str | None[Quelle]#: Versucht, Ratschläge aus dem gegebenen Text zu extrahieren und in den Speicher aufzunehmen.

async handle_user_message(text: str, should_await: bool = True) → str[Quelle]#: Behandelt eine Benutzernachricht, indem Ratschläge als zu speichernde Erkenntnis extrahiert und dann assign_task() aufgerufen wird.

class MemoryControllerConfig[Quelle]#

Bases: TypedDict

generalize_task: bool#

revise_generalized_task: bool#

generate_topics: bool#

validate_memos: bool#

max_memos_to_retrieve: int#

max_train_trials: int#

max_test_trials: int#

MemoryBank: MemoryBankConfig#

class MemoryBankConfig[Quelle]#

Bases: TypedDict

path: str#

relevance_conversion_threshold: float#

n_results: int#

distance_threshold: int#