autogen_core.memory#

class Memory[Quelle]#

Bases: ABC, ComponentBase[BaseModel]

Protokoll zur Definition der Schnittstelle für Speicherimplementierungen.

Ein Speicher ist die Speicherung von Daten, die verwendet werden können, um den Modellkontext anzureichern oder zu ändern.

Eine Speicherimplementierung kann jeden Speichermechanismus verwenden, z. B. eine Liste, eine Datenbank oder ein Dateisystem. Sie kann auch jeden Abrufmechanismus verwenden, z. B. Vektorsuche oder Textsuche. Es liegt an der Implementierung zu entscheiden, wie Daten gespeichert und abgerufen werden.

Es liegt auch in der Verantwortung einer Speicherimplementierung, den Modellkontext mit relevanten Speicherinhalten zu aktualisieren, basierend auf dem aktuellen Modellkontext und der Abfrage des Speicherdatenspeichers.

Siehe ListMemory für ein Beispiel für eine Implementierung.

component_type: ClassVar[ComponentType] = 'memory'#: Der logische Typ der Komponente.

abstract async update_context(model_context: ChatCompletionContext) → UpdateContextResult[Quelle]#

Aktualisieren Sie den bereitgestellten Modellkontext mit relevanten Speicherinhalten.

Parameter:: model_context – Der zu aktualisierende Kontext.
Gibt zurück:: UpdateContextResult mit relevanten Speichern

abstract async query(query: str | MemoryContent, cancellation_token: CancellationToken | None = None, **kwargs: Any) → MemoryQueryResult[Quelle]#

Fragen Sie den Speicherdatenspeicher ab und geben Sie relevante Einträge zurück.

Parameter:

query – Inhaltselement der Abfrage
cancellation_token – Optionales Token zum Abbrechen der Operation
**kwargs – Zusätzliche implementierungsspezifische Parameter

Gibt zurück:

MemoryQueryResult mit Relevanzbewertungen enthaltenden Speicherbereichen

abstract async add(content: MemoryContent, cancellation_token: CancellationToken | None = None) → None[Quelle]#

Fügen Sie einen neuen Inhalt zum Speicher hinzu.

Parameter:

content – Der hinzuzufügende Speicherinhalt
cancellation_token – Optionales Token zum Abbrechen der Operation

abstract async clear() → None[Quelle]#: Löschen Sie alle Einträge aus dem Speicher.

abstract async close() → None[Quelle]#: Bereinigen Sie alle von der Speicherimplementierung verwendeten Ressourcen.

pydantic model MemoryContent[Quelle]#

Bases: BaseModel

Ein Speicherinhaltselement.

JSON-Schema anzeigen

{
   "title": "MemoryContent",
   "description": "A memory content item.",
   "type": "object",
   "properties": {
      "content": {
         "anyOf": [
            {
               "type": "string"
            },
            {
               "format": "binary",
               "type": "string"
            },
            {
               "type": "object"
            },
            {}
         ],
         "title": "Content"
      },
      "mime_type": {
         "anyOf": [
            {
               "$ref": "#/$defs/MemoryMimeType"
            },
            {
               "type": "string"
            }
         ],
         "title": "Mime Type"
      },
      "metadata": {
         "anyOf": [
            {
               "type": "object"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "title": "Metadata"
      }
   },
   "$defs": {
      "MemoryMimeType": {
         "description": "Supported MIME types for memory content.",
         "enum": [
            "text/plain",
            "application/json",
            "text/markdown",
            "image/*",
            "application/octet-stream"
         ],
         "title": "MemoryMimeType",
         "type": "string"
      }
   },
   "required": [
      "content",
      "mime_type"
   ]
}

Felder:

content (str | bytes | Dict[str, Any] | autogen_core._image.Image)
metadata (Dict[str, Any] | None)
mime_type (autogen_core.memory._base_memory.MemoryMimeType | str)

field content: str | bytes | Dict[str, Any] | Image [Erforderlich]#: Der Inhalt des Speicherelements. Dies kann ein String, Bytes, ein Dict oder ein Image sein.

field mime_type: MemoryMimeType | str [Erforderlich]#: Der MIME-Typ des Speicherinhalts.

field metadata: Dict[str, Any] | None = None#: Metadaten, die mit dem Speicherelement verbunden sind.

serialize_mime_type(mime_type: MemoryMimeType | str) → str[Quelle]#: Serialisieren Sie den MIME-Typ in einen String.

pydantic model MemoryQueryResult[Quelle]#

Bases: BaseModel

Ergebnis einer Speicherabfrageoperation (query()).

JSON-Schema anzeigen

{
   "title": "MemoryQueryResult",
   "description": "Result of a memory :meth:`~autogen_core.memory.Memory.query` operation.",
   "type": "object",
   "properties": {
      "results": {
         "items": {
            "$ref": "#/$defs/MemoryContent"
         },
         "title": "Results",
         "type": "array"
      }
   },
   "$defs": {
      "MemoryContent": {
         "description": "A memory content item.",
         "properties": {
            "content": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "format": "binary",
                     "type": "string"
                  },
                  {
                     "type": "object"
                  },
                  {}
               ],
               "title": "Content"
            },
            "mime_type": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/MemoryMimeType"
                  },
                  {
                     "type": "string"
                  }
               ],
               "title": "Mime Type"
            },
            "metadata": {
               "anyOf": [
                  {
                     "type": "object"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Metadata"
            }
         },
         "required": [
            "content",
            "mime_type"
         ],
         "title": "MemoryContent",
         "type": "object"
      },
      "MemoryMimeType": {
         "description": "Supported MIME types for memory content.",
         "enum": [
            "text/plain",
            "application/json",
            "text/markdown",
            "image/*",
            "application/octet-stream"
         ],
         "title": "MemoryMimeType",
         "type": "string"
      }
   },
   "required": [
      "results"
   ]
}

Felder:

results (List[autogen_core.memory._base_memory.MemoryContent])

field results: List[MemoryContent] [Erforderlich]#

pydantic model UpdateContextResult[Quelle]#

Bases: BaseModel

Ergebnis einer Speicheroperation zur Kontextaktualisierung (update_context()).

JSON-Schema anzeigen

{
   "title": "UpdateContextResult",
   "description": "Result of a memory :meth:`~autogen_core.memory.Memory.update_context` operation.",
   "type": "object",
   "properties": {
      "memories": {
         "$ref": "#/$defs/MemoryQueryResult"
      }
   },
   "$defs": {
      "MemoryContent": {
         "description": "A memory content item.",
         "properties": {
            "content": {
               "anyOf": [
                  {
                     "type": "string"
                  },
                  {
                     "format": "binary",
                     "type": "string"
                  },
                  {
                     "type": "object"
                  },
                  {}
               ],
               "title": "Content"
            },
            "mime_type": {
               "anyOf": [
                  {
                     "$ref": "#/$defs/MemoryMimeType"
                  },
                  {
                     "type": "string"
                  }
               ],
               "title": "Mime Type"
            },
            "metadata": {
               "anyOf": [
                  {
                     "type": "object"
                  },
                  {
                     "type": "null"
                  }
               ],
               "default": null,
               "title": "Metadata"
            }
         },
         "required": [
            "content",
            "mime_type"
         ],
         "title": "MemoryContent",
         "type": "object"
      },
      "MemoryMimeType": {
         "description": "Supported MIME types for memory content.",
         "enum": [
            "text/plain",
            "application/json",
            "text/markdown",
            "image/*",
            "application/octet-stream"
         ],
         "title": "MemoryMimeType",
         "type": "string"
      },
      "MemoryQueryResult": {
         "description": "Result of a memory :meth:`~autogen_core.memory.Memory.query` operation.",
         "properties": {
            "results": {
               "items": {
                  "$ref": "#/$defs/MemoryContent"
               },
               "title": "Results",
               "type": "array"
            }
         },
         "required": [
            "results"
         ],
         "title": "MemoryQueryResult",
         "type": "object"
      }
   },
   "required": [
      "memories"
   ]
}

Felder:

memories (autogen_core.memory._base_memory.MemoryQueryResult)

field memories: MemoryQueryResult [Erforderlich]#

class MemoryMimeType(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)[Quelle]#

Bases: Enum

Unterstützte MIME-Typen für Speicherinhalte.

TEXT = 'text/plain'#

JSON = 'application/json'#

MARKDOWN = 'text/markdown'#

IMAGE = 'image/*'#

BINARY = 'application/octet-stream'#

class ListMemory(name: str | None = None, memory_contents: List[MemoryContent] | None = None)[Quelle]#

Bases: Memory, Component[ListMemoryConfig]

Einfache chronologische Listen-basierte Speicherimplementierung.

Diese Speicherimplementierung speichert Inhalte in einer Liste und ruft sie chronologisch ab. Sie verfügt über eine Methode update_context, die Modellkontexte aktualisiert, indem sie alle gespeicherten Speicher hinzufügt.

Auf den Speicherinhalt kann direkt über die Eigenschaft content zugegriffen und dieser geändert werden, sodass externe Anwendungen Speicherinhalte direkt verwalten können.

Beispiel

import asyncio
from autogen_core.memory import ListMemory, MemoryContent
from autogen_core.model_context import BufferedChatCompletionContext


async def main() -> None:
    # Initialize memory
    memory = ListMemory(name="chat_history")

    # Add memory content
    content = MemoryContent(content="User prefers formal language", mime_type="text/plain")
    await memory.add(content)

    # Directly modify memory contents
    memory.content = [MemoryContent(content="New preference", mime_type="text/plain")]

    # Create a model context
    model_context = BufferedChatCompletionContext(buffer_size=10)

    # Update a model context with memory
    await memory.update_context(model_context)

    # See the updated model context
    print(await model_context.get_messages())


asyncio.run(main())

Parameter:: name – Optionale Kennung für diese Speicherinstanz

component_type: ClassVar[ComponentType] = 'memory'#: Der logische Typ der Komponente.

component_provider_override: ClassVar[str | None] = 'autogen_core.memory.ListMemory'#: Überschreibe den Anbieter-String für die Komponente. Dies sollte verwendet werden, um zu verhindern, dass interne Modulnamen Teil des Modulnamens werden.

component_config_schema#: Alias von ListMemoryConfig

property name: str#

Rufen Sie die Kennung der Speicherinstanz ab.

Gibt zurück:: str – Name der Speicherinstanz

property content: List[MemoryContent]#

Rufen Sie die aktuellen Speicherinhalte ab.

Gibt zurück:: List[MemoryContent] – Liste der gespeicherten Speicherinhalte

async update_context(model_context: ChatCompletionContext) → UpdateContextResult[Quelle]#

Aktualisieren Sie den Modellkontext, indem Sie Speicherinhalte anhängen.

Diese Methode modifiziert den bereitgestellten model_context, indem sie alle Speicher als SystemMessage hinzufügt.

Parameter:: model_context – Der zu aktualisierende Kontext. Wird geändert, wenn Speicher vorhanden sind.
Gibt zurück:: UpdateContextResult, die die dem Kontext hinzugefügten Speicher enthalten

async query(query: str | MemoryContent = '', cancellation_token: CancellationToken | None = None, **kwargs: Any) → MemoryQueryResult[Quelle]#

Geben Sie alle Speicher ohne Filterung zurück.

Parameter:

query – In dieser Implementierung ignoriert
cancellation_token – Optionales Token zum Abbrechen der Operation
**kwargs – Zusätzliche Parameter (ignoriert)

Gibt zurück:

MemoryQueryResult, das alle gespeicherten Speicher enthält

async add(content: MemoryContent, cancellation_token: CancellationToken | None = None) → None[Quelle]#

Fügen Sie neuen Inhalt zum Speicher hinzu.

Parameter:

content – Zu speichernder Speicherinhalt
cancellation_token – Optionales Token zum Abbrechen der Operation

async clear() → None[Quelle]#: Löschen Sie alle Speicherinhalte.

async close() → None[Quelle]#: Ressourcen bei Bedarf bereinigen.

classmethod _from_config(config: ListMemoryConfig) → Self[Quelle]#

Erstelle eine neue Instanz der Komponente aus einem Konfigurationsobjekt.

Parameter:: config (T) – Das Konfigurationsobjekt.
Gibt zurück:: Self – Die neue Instanz der Komponente.

_to_config() → ListMemoryConfig[Quelle]#

Gib die Konfiguration aus, die erforderlich wäre, um eine neue Instanz einer Komponente zu erstellen, die der Konfiguration dieser Instanz entspricht.

Gibt zurück:: T – Die Konfiguration der Komponente.