Samouczek: Dodaj sesje i pamięć do istniejącego agenta

Jeśli już zbudowałeś agenta w Python, możesz nadać mu trwałą historię rozmów i pamięć długoterminową w Azure Databricks bez konieczności przepisywania go na nowo. W tym samouczku łączysz agenta z magazynem sesji, który utrwala każdą rozmowę, magazynem pamięci przechowującym trwałe fakty między rozmowami oraz potokiem pamięci, który wyodrębnia z zapisanych rozmów informacje do pamięci. Kroki obejmują agentów zbudowanych w OpenAI Agents SDK, LangGraph lub innym frameworku Python, niezależnie od tego, gdzie agent działa.

W tym przykładzie agent wsparcia powinien wznowić rozmowę z klientem od miejsca, w którym została przerwana, i zapamiętać preferencje klienta w późniejszych, oddzielnych rozmowach.

Aby dowiedzieć się, jak sesje i pamięć się ze sobą łączą, zobacz pamięć agenta i sesje.

Requirements

• Istniejący agent napisany w Python 3.10 lub nowszy. Kroki specyficzne dla frameworka obejmują OpenAI Agents SDK oraz LangGraph. Kroki dla innych frameworków wywołują bezpośrednio AgentKit SDK.
• Uwierzytelnianie Azure Databricks. SDK AgentKit korzysta z domyślnego uwierzytelniania Databricks SDK for Python. Do programowania lokalnego uruchom databricks auth login --host <workspace-url> lub ustaw zmienne środowiskowe DATABRICKS_HOST i DATABRICKS_TOKEN.
• Użyj Databricks CLI, aby sprawdzić status uruchomień potoku pamięci.
• Aby utworzyć potok pamięci, wymagane są uprawnienia do wykonywania zapytań do modelu używanego przez potok oraz pozostałe elementy dostępu wymienione w wymaganiach potoku pamięci.

Krok 1: Zainstaluj AgentKit SDK oraz Agent Bricks CLI

Pakiet databricks-agentbricks zawiera następujące elementy:

• AgentKit SDK (databricks_agentkit), klient Python do przechowywania sesji i pamięci.
• Agent Bricks CLI (agentbricks).
• Adaptery do OpenAI Agents SDK i LangGraph, które łączą magazyny sesji i pamięci z istniejącymi interfejsami sesji i narzędzi każdego frameworka. Adaptery korzystają z pakietów frameworkowych, które Twój agent już ma zainstalowane.

Zainstaluj wersję 0.6.0 lub nowszą w środowisku swojego agenta:

pip install --upgrade "databricks-agentbricks>=0.6.0"

Krok 2: Stwórz magazyn sesji i magazyn pamięci

Twój agent korzysta z dwóch magazynów, którymi zarządza Azure Databricks za Ciebie:

• Magazyn sesji przechowuje historię rozmów. Każda sesja w niej to transkrypcja jednej rozmowy, którą agent ponownie ładuje, by kontynuować ją tam, gdzie została przerwana.
• Magazyn pamięci przechowuje trwałe informacje o każdym użytkowniku, takie jak preferencje i wcześniejsze decyzje. Agent przeszukuje go, by przypomnieć sobie, czego nauczył się we wcześniejszych, oddzielnych rozmowach.

Magazyn kluczy stanowi granicę bezpieczeństwa: każdy podmiot mający dostęp do magazynu kluczy może odczytać i zapisać wszystkie jego wpisy. Aby odizolować najemców od siebie nawzajem, stwórz osobną parę magazynów danych dla każdego najemcy. Zobacz Partycjonowanie i pamięć zabezpieczoną.

Stwórz każdy sklep tylko raz i używaj go ponownie w każdej rozmowie. Twój agent odnosi się do obu sklepów, używając ich nazw.

AgentKit SDK

from databricks.sdk import WorkspaceClient
from databricks_agentkit import AgentKitClient

client = AgentKitClient(WorkspaceClient())
client.session_stores.create("support-agent-sessions", description="Support agent conversations")
client.memory_stores.create("support-agent-memory", description="Support agent long-term memory")

Agent Bricks

agentbricks sessions stores create --name support-agent-sessions --description "Support agent conversations"
agentbricks memory stores create --display-name support-agent-memory --description "Support agent long-term memory"

interfejs API REST

Ustaw DATABRICKS_HOST na nazwę hosta swojego workspace, a następnie uruchom poniższe:

export DATABRICKS_TOKEN=$(databricks auth token --profile <profile> | jq -r .access_token)

curl -X POST "https://${DATABRICKS_HOST}/api/2.0/agents/session-stores?session_store_id=support-agent-sessions" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" -H "Content-Type: application/json" \
  -d '{"description": "Support agent conversations"}'

curl -X POST "https://${DATABRICKS_HOST}/api/2.0/agents/memory-stores?managed_memory_store_id=support-agent-memory" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" -H "Content-Type: application/json" \
  -d '{"description": "Support agent long-term memory"}'

ID sklepów muszą być unikalne w przestrzeni roboczej. Identyfikator magazynu pamięci musi mieć od 3 do 56 znaków, zaczynać się od małej litery, kończyć na literę lub cyfrę i zawierać jedynie małe litery, cyfry i łączniki. ID magazynu sesji musi mieć od 3 do 55 znaków.

Krok 3: Wybierz identyfikatory aktora i sesji

Każde połączenie Twojego agenta do sklepów ma dwa identyfikatory:

• actor_id identyfikuje, czyje to rozmowy i wspomnienia. Oba magazyny go używają, a potok pamięci zapisuje wspomnienia każdego aktora pod tym samym actor_id, co sesje tego aktora, więc agent przywołuje skondensowane wspomnienia tylko wtedy, gdy oba się zgadzają.
• session_id identyfikuje jedną rozmowę, tak aby kolejne żądanie ją wznowiło.

W tym samouczku użyj test-user jako actor_id, a conversation-1 jako session_id. Funkcje handle_message w kolejnych krokach przyjmują je jako user_id i conversation_id.

W produkcji ustaw actor_id w kodzie aplikacji z zaufanego kontekstu żądania, takiego jak zweryfikowana tożsamość zalogowanego użytkownika, i nigdy nie pozwalaj, by model lub wiadomość użytkownika ją wybrały. Aby udostępnić pamięć w zespole lub wyizolować dzierżawców, zobacz Podział i zabezpieczenie pamięci. Dla session_id, użyj istniejącego identyfikatora rozmowy lub identyfikatora wątku swojej aplikacji albo wygeneruj UUID na początku rozmowy.

Krok 4: Przechowuj rozmowy w magazynie sesji

Historia rozmowy to uporządkowany zapis jednej rozmowy: wiadomości użytkownika, odpowiedzi agenta oraz wywołań narzędzi i ich wyników. Magazyn sesji zapisuje tę historię dla każdej rozmowy, dzięki czemu agent może ją wczytać przy kolejnym żądaniu, nawet po ponownym uruchomieniu. Zamień historię rozmów w pamięci procesu swojego agenta na magazyn sesji, który stworzyłeś w kroku 2.

Adaptery frameworków podłączają się do interfejsu, którego każdy framework już używa dla stanu sesji, dzięki czemu model, narzędzia i prompty Twojego agenta pozostają takie same.

Zestaw SDK agentów OpenAI

SDK OpenAI Agents odczytuje i zapisuje historię rozmów przez obiekt Session. session_store() zwraca Session obsługiwany przez zarządzany magazyn sesji. Przekaż do Runner.run:

from agents import Agent, Runner
from databricks_agentkit.openai import session_store

SESSION_STORE = "support-agent-sessions"

# Your existing agent, unchanged.
agent = Agent(name="Support agent", instructions="You help customers with their Databricks workspaces.")

async def handle_message(user_id: str, conversation_id: str, message: str) -> str:
    session = session_store(conversation_id, actor=user_id, store=SESSION_STORE)
    result = await Runner.run(agent, message, session=session)
    return result.final_output

Przy pierwszej wiadomości w rozmowie adapter tworzy sesję. Przy każdym uruchomieniu SDK ładuje historię rozmowy z sesji i dodaje nową wiadomość użytkownika, wyniki modelu oraz elementy narzędzi.

LangGraph

LangGraph zachowuje stan grafu poprzez mechanizm checkpointów oznaczony identyfikatorem wątku. checkpointer() Zwraca checkpointer wspierany przez managed session store i thread_config() mapuje rozmowę oraz jej użytkownika na wątek:

from langchain.agents import create_agent
from databricks_agentkit.langgraph import checkpointer, thread_config

SESSION_STORE = "support-agent-sessions"

# Your existing model and tools, unchanged, with the managed checkpointer added.
agent = create_agent(model=model, tools=tools, checkpointer=checkpointer(store=SESSION_STORE))

async def handle_message(user_id: str, conversation_id: str, message: str) -> str:
    result = await agent.ainvoke(
        {"messages": [{"role": "user", "content": message}]},
        config=thread_config(conversation_id, actor=user_id),
    )
    return result["messages"][-1].content

Jeśli Twój agent już używa checkpointera, zastąp go checkpointer(). Jeśli zbudujesz bezpośrednio StateGraph, przekaż checkpointer do compile(). Mechanizm punktu kontrolnego przechowuje pełny stan grafu, w tym przerwania wymagające interwencji człowieka, dzięki czemu zatrzymany przebieg może zostać wznowiony po ponownym uruchomieniu.

Inne frameworki

W przypadku innych frameworków lub bezpośrednich wywołań modeli odczytaj i dołącz historię rozmów za pomocą pakietu SDK AgentKit. Przechowuj każdą wiadomość jako {"type": "message", "role": "user" | "assistant", "content": "<text>"}. Potok pamięci streszcza wiadomości użytkownika i asystenta w tej postaci, a także w postaci wiadomości OpenAI Responses z częściami tekstowymi. Pomija wszystkie inne elementy, takie jak wywołania narzędzi i wyniki narzędzi.

from databricks.sdk import WorkspaceClient
from databricks_agentkit import AgentKitClient

client = AgentKitClient(WorkspaceClient())
session_store = client.session_stores.get("support-agent-sessions")

def start_conversation(user_id: str, conversation_id: str) -> None:
    session_store.add(actor_id=user_id, session_id=conversation_id)

def handle_message(user_id: str, conversation_id: str, message: str) -> str:
    session = session_store.get(conversation_id)
    if session.actor_id != user_id:
        raise PermissionError("This conversation belongs to a different user.")

    # Rebuild context from the stored history, oldest first.
    history = [item.data for item in session.list_items(order_by="create_time asc")]
    user_item = {"type": "message", "role": "user", "content": message}
    reply = run_agent([*history, user_item])  # Your framework or model call.

    session.append_items([user_item, {"type": "message", "role": "assistant", "content": reply}])
    return reply

Wyszukiwanie sesji według session_id nie jest ograniczone do aktora, więc sprawdź, czy sesja należy do użytkownika żądającego, zanim ją wznowisz.

Przełączenie do magazynu sesji nie przenosi rozmów, które agent przechowywał, gdzie indziej. Aby przenieść istniejącą rozmowę, dołącz jej elementy do nowej sesji.

Krok 5: Nadaj agentowi pamięć

Historia sesji obejmuje jedną rozmowę. Aby wykorzystać to, czego agent nauczył się we wcześniejszych rozmowach, połącz go z magazynem pamięci. Są dwa wzory i można je łączyć:

• Narzędzia pamięci: Model decyduje, kiedy odwołać się do pamięci, a kiedy zapisać nowy fakt.
• Przypomnij przed każdym uruchomieniem: Twoja aplikacja przeszukuje pamięć pod kątem nadchodzącego komunikatu i dodaje wyniki do kontekstu agenta, dzięki czemu agent widzi odpowiednią pamięć bez wywoływania narzędzia.

Jeśli potok pamięci zapisuje twoją pamięć (patrz Krok 6), agent musi jedynie przywołać pamięć. Możesz pominąć narzędzia zapisujące pamięć.

Zestaw SDK agentów OpenAI

Poniższy przykład wykorzystuje oba wzorce w kopii Twojego agenta tworzonej dla każdego żądania:

• memory_tools() Zwraca cztery narzędzia: recall przeszukuje pamięć użytkownika, remember zapisuje fakt pod tematem, forget usuwa fakt i list_memories wypisuje to, co jest zapisane. Narzędzia są powiązane z jednym aktorem, więc model nie może odczytywać ani zapisywać pamięci innego użytkownika.
• recalled_facts() przeszukuje pamięć pod kątem nadchodzącej wiadomości przed uruchomieniem i dodaje wyniki do instrukcji agenta.

from databricks.sdk import WorkspaceClient
from databricks_agentkit import AgentKitClient
from databricks_agentkit.openai import memory_tools, session_store

MEMORY_STORE = "support-agent-memory"
memory_store = AgentKitClient(WorkspaceClient()).memory_stores.get(MEMORY_STORE)

def recalled_facts(user_id: str, message: str) -> str:
    results = memory_store.search(actor_id=user_id, query=message, limit=5)
    return "\n".join(f"- {r.memory.content}" for r in results)

async def handle_message(user_id: str, conversation_id: str, message: str) -> str:
    instructions = agent.instructions  # Your agent's existing instructions, as a string.
    if facts := recalled_facts(user_id, message):  # Recall before the run.
        instructions += f"\n\nWhat you know about this user:\n{facts}"
    user_agent = agent.clone(
        instructions=instructions,
        tools=[*agent.tools, *memory_tools(user_id, store=MEMORY_STORE)],  # Memory tools.
    )
    session = session_store(conversation_id, actor=user_id, store=SESSION_STORE)
    result = await Runner.run(user_agent, message, session=session)
    return result.final_output

Przywołane fakty trafiają do instrukcji, a nie do wejścia, więc sesja ich nie przechowuje. Aby użyć tylko jednego wzoru, porzuć drugi: usuń linię memory_tools() lub usuń wywołanie recalled_facts(). Jeśli zachowasz narzędzia, zaktualizuj instrukcje agenta, aby określić, kiedy ma ich używać, na przykład: „Użyj recall, aby sprawdzić preferencje użytkownika przed odpowiedzią.” Użyj funkcji „remember”, aby zapisywać trwałe informacje, które użytkownik udostępnia. Użyj „forget”, gdy użytkownik prosi cię o zapomnienie czegoś.

LangGraph

Poniższy przykład wykorzystuje oba wzorce i buduje agenta dla każdego żądania. Checkpointer jest tworzony raz i udostępniany:

• memory_tools() Zwraca cztery narzędzia: recall przeszukuje pamięć użytkownika, remember zapisuje fakt w temacie, forget usuwa fakt i list_memories wypisuje to, co jest zapisane. Narzędzia są powiązane z jednym aktorem, więc model nie może odczytywać ani zapisywać pamięci innego użytkownika.
• recalled_facts() przeszukuje pamięć pod kątem przychodzącej wiadomości przed uruchomieniem i dodaje wyniki do komunikatu systemowego.

from databricks.sdk import WorkspaceClient
from databricks_agentkit import AgentKitClient
from langchain.agents import create_agent
from databricks_agentkit.langgraph import checkpointer, memory_tools, thread_config

MEMORY_STORE = "support-agent-memory"
memory_store = AgentKitClient(WorkspaceClient()).memory_stores.get(MEMORY_STORE)

def recalled_facts(user_id: str, message: str) -> str:
    results = memory_store.search(actor_id=user_id, query=message, limit=5)
    return "\n".join(f"- {r.memory.content}" for r in results)

async def handle_message(user_id: str, conversation_id: str, message: str) -> str:
    system_prompt = SYSTEM_PROMPT  # Tell the agent when to use the memory tools.
    if facts := recalled_facts(user_id, message):  # Recall before the run.
        system_prompt += f"\n\nWhat you know about this user:\n{facts}"
    agent = create_agent(
        model=model,
        tools=[*tools, *memory_tools(user_id, store=MEMORY_STORE)],  # Memory tools.
        system_prompt=system_prompt,
        checkpointer=checkpointer(store=SESSION_STORE),
    )
    result = await agent.ainvoke(
        {"messages": [{"role": "user", "content": message}]},
        config=thread_config(conversation_id, actor=user_id),
    )
    return result["messages"][-1].content

LangGraph dodaje system prompt do każdego wywołania modelu, nie zapisując go w stanie grafu, więc checkpointer nie przechowuje przypomnianych faktów. Aby użyć tylko jednego wzoru, porzuć drugi: usuń linię memory_tools() lub usuń wywołanie recalled_facts().

Inne frameworki

Przeszukaj pamięć w poszukiwaniu przychodzącej wiadomości przed każdym uruchomieniem i przekaż wyniki agentowi jako kontekst. Wyszukiwanie pasuje zarówno do słów kluczowych, jak i znaczenia, więc wiadomość użytkownika dobrze sprawdza się jako zapytanie.

memory_store = client.memory_stores.get("support-agent-memory")

def recall(user_id: str, message: str) -> list[dict]:
    results = memory_store.search(actor_id=user_id, query=message, limit=5)
    if not results:
        return []
    facts = "\n".join(f"- {r.memory.content}" for r in results)
    return [{"role": "system", "content": f"What you know about this user:\n{facts}"}]

W handle_message z kroku 4 dodaj przypomniany kontekst do wejścia agenta. Nie dodawaj tego do sesji:

reply = run_agent([*recall(user_id, message), *history, user_item])

Aby agent mógł samodzielnie zapisywać pamięć, opakuj operacje search i add magazynu jako narzędzia dla swojego frameworka. Zobacz Nadaj agentowi narzędzia pamięci.

Krok 6: Stwórz potok pamięciowy

Potok pamięci odczytuje rozmowy w magazynie sesji i wyodrębnia trwałe fakty, preferencje oraz decyzje dla każdego aktora, zapisując je w magazynie pamięci. Łączy też nakładające się z upływem czasu wpisy, dzięki czemu pamięć agenta pozostaje skonsolidowana bez dodatkowego kodu agenta.

1. Stwórz pipeline łączący oba magazyny:

   agentbricks memory pipeline create \
     --session-store support-agent-sessions \
     --memory-store support-agent-memory \
     --trigger scheduled \
     --model system.ai.claude-sonnet-5 \
     --instructions "Focus on durable customer preferences and account details. Ignore one-off troubleshooting steps."
   

   • --trigger scheduled uruchamia potok automatycznie mniej więcej co 24 godziny. Bez niego pipeline używa domyślnego wyzwalacza, manual, i uruchamia się tylko wtedy, gdy rozpoczniesz uruchomienie. Zobacz Uruchamiaj pipeline według harmonogramu.
   • --model Ustawia model, który destyluje wspomnienia. Możesz użyć dowolnego modelu, do którego masz uprawnienia do zapytań. Jeśli pominiesz --model, pipeline używa domyślnego modelu wybranego przez Azure Databricks.
   • --instructions jest opcjonalne i reguluje to, co pipeline zachowuje. Zobacz destylację Steer z instrukcjami.

   Polecenie zwraca nazwę zasobu potoku w postaci memory-pipelines/<pipeline-id>. Dla każdej opcji uruchom agentbricks memory pipeline create --help lub zobacz referencję do poleceń Agent Bricks CLI.

2. Harmonogram decyduje, kiedy rozpocznie się pierwsze zaplanowane uruchomienie. Aby wyodrębnić rozmowy już dostępne w pamięci sesji, uruchom przebieg teraz:

   agentbricks memory pipeline run <pipeline-id>
   

   Polecenie zwraca nazwę zasobu przebiegu w postaci memory-pipelines/<pipeline-id>/runs/<run-id>.

3. Sprawdź wynik przebiegu za pomocą REST API. Ustaw DATABRICKS_HOST na nazwę hosta swojego workspace, a następnie uruchom poniższe:

   export DATABRICKS_TOKEN=$(databricks auth token --profile <profile> | jq -r .access_token)
   curl "https://${DATABRICKS_HOST}/api/2.0/agents/memory-pipelines/<pipeline-id>/runs/<run-id>" \
     -H "Authorization: Bearer ${DATABRICKS_TOKEN}"
   

   Gdy state uruchomienia jest SUCCEEDED, wydestylowane wspomnienia znajdują się w magazynie pamięci.

Uruchomienia potoku używają tożsamości, która utworzyła potok, a nie tożsamości agenta. Potok przetwarzania może przepisywać, scalać lub usuwać dowolny wpis pod elementem actor_id, który przetwarza, w tym wpisy zapisane przez agenta za pomocą narzędzi pamięci. Aby poznać API REST, stany uruchomienia i ograniczenia, zobacz Potoki pamięci agenta.

Nagrywanie transkrypcji dla agentów LangGraph

Potok pamięci destyluje wyłącznie komunikaty użytkownika i asystenta. Checkpointer LangGraph przechowuje zserializowane punkty kontrolne, więc pipeline odczytujący magazyn sesji checkpointera nie znajduje żadnych komunikatów do destylacji. Aby użyć potoku z agentem LangGraph, należy również dodać wiadomości z każdej tury do osobnego magazynu sesji i utworzyć potok w tym magazynie:

transcripts = client.session_stores.create("support-agent-transcripts")  # Create once.

def start_conversation(user_id: str, conversation_id: str) -> None:
    transcripts.add(actor_id=user_id, session_id=conversation_id)

def record_turn(conversation_id: str, message: str, reply: str) -> None:
    transcripts.get(conversation_id).append_items(
        [
            {"type": "message", "role": "user", "content": message},
            {"type": "message", "role": "assistant", "content": reply},
        ]
    )

Wywołaj start_conversation, gdy rozmowa się zaczyna, przed jej pierwszą ainvoke, i wywołuj record_turn po każdym ainvoke. Przekaż --session-store support-agent-transcripts podczas tworzenia pipeline’u. Alternatywnie, pomiń pipeline i pozwól agentowi zapisywać dane w pamięci za pomocą narzędzi pamięciowych.

Krok 7: Przyznaj wdrożonemu agentowi dostęp

Gdy uruchamiasz agenta lokalnie, używa on twoich własnych danych uwierzytelniających. Wdrożony agent zwykle działa jako jednostka usługi, która potrzebuje dostępu do każdego magazynu, który odczytuje lub do którego zapisuje. Udziel dostępu za pomocą zestawu SDK AgentKit, przekazując identyfikator aplikacji (klienta) nazwy głównej usługi:

from databricks.sdk import WorkspaceClient
from databricks_agentkit import AgentKitClient

w = WorkspaceClient()
client = AgentKitClient(w)

# For an agent deployed as a Databricks app, look up the app's service principal.
sp_client_id = w.apps.get("support-agent").service_principal_client_id

client.session_stores.get("support-agent-sessions").grant_permission(sp_client_id)
client.memory_stores.get("support-agent-memory").grant_permission(sp_client_id)

grant_permission domyślnie przyznaje dostęp do zapisu. Aby udzielić dostępu tylko do odczytu, należy przekazać permission="READ". Jeśli utworzyłeś magazyn transkrypcji dla agenta LangGraph, również przyznaj do niego dostęp. Memory pipeline nie wymaga grantu dla nazwy głównej usługi twojego agenta, ponieważ uruchomienia potoku używają tożsamości, która go utworzyła.

Krok 8: Przetestuj agenta od początku do końca

1. Zadzwoń do handle_message z conversation_id="conversation-1" i user_id="test-user", i podziel się stałą preferencją, na przykład „Wolę kontakt e-mailowy zamiast telefonu i jestem w strefie czasowej Pacific.” Jeśli postępowałeś zgodnie z instrukcjami dla innych frameworków, najpierw zadzwoń start_conversation("test-user", "conversation-1"). Wyślij wiadomość uzupełniającą w tej samej rozmowie i potwierdź, że agent zna wcześniejszy kontekst.

2. Potwierdź, że magazyn sesji przechowuje rozmowę:

   agentbricks sessions items list --store support-agent-sessions --session-id conversation-1
   

3. Rozpocznij uruchomienie potoku pamięci i poczekaj, aż jego stan state to SUCCEEDED, jak w kroku 6.

4. Potwierdź, że magazyn pamięci zawiera preferencje użytkownika testowego:

   agentbricks memory entries search --store support-agent-memory --actor-id test-user --query "contact preferences"
   

5. Rozpocznij nową rozmowę dla test-user z conversation_id="conversation-2" i zapytaj: „Jak powinieneś się ze mną skontaktować?” Agent odpowiada z pamięci.

Troubleshooting

• PERMISSION_DENIED (HTTP 403) od wdrożonego agenta. Agent service principal nie może uzyskać dostępu do sklepu. Daj mu dostęp, jak w kroku 7.
• Uruchomienie potoku kończy się sukcesem, ale nie zapisuje żadnych wpisów. Potwierdź, że magazyn sesji przechowuje wiadomości użytkownika i asystenta w formie, którą odczytuje potok. Potok pomija wywołania narzędzi, wyniki narzędzi oraz punkty kontrolne LangGraph. Run przetwarza tylko tury dodane od punktu kontrolnego aktora, a tury z ostatnich 60 sekund czekają na kolejny run.
• Agent nie pamięta wyodrębnionych wspomnień. Potwierdź, że agent przeszukuje pamięć przy użyciu tego samego actor_id, którego używają jego sesje.
• Rozpoczęcie przebiegu kończy się niepowodzeniem z błędem ABORTED. Trwa kolejne uruchomienie potoku. Poczekaj, aż się skończy, a potem zacznij nowe uruchomienie.

Czyszczenie

Aby usunąć zasoby utworzone przez ten samouczek, uruchom następujące polecenie. Usunięcie sklepu usuwa wszystko w nim.

agentbricks memory pipeline delete <pipeline-id>
agentbricks sessions stores delete support-agent-sessions
agentbricks memory stores delete support-agent-memory

Następne kroki

• Sesje agentów
• Pamięć agenta
• Potoki pamięci agenta
• Agent Bricks CLI