Memory

MEMORY_FILE = "/memories/AGENTS.md"
 
#: Fixed namespace: every thread of this demo shares one memory. A real
#: deployment would scope it, e.g. `lambda rt: (rt.server_info.user.identity,)`.
MEMORY_NAMESPACE = ("cockpit", "deep-agents-memory")
 
#: Custom stream event name the Angular panel listens for.
MEMORY_EVENT = "deep_agents.memory"

def build_memory_agent():
    """Build the memory agent.
 
    `store=None` on `StoreBackend` means "resolve the store from the graph
    execution context", which is what the LangGraph server supplies. The
    namespace factory ignores its runtime argument on purpose, so every thread
    of this demo reads and writes the same memory.
    """
    return create_deep_agent(
        model=ChatOpenAI(model="gpt-4.1", temperature=0),
        system_prompt=(PROMPTS_DIR / "memory.md").read_text(),
        backend=StoreBackend(namespace=lambda _runtime: MEMORY_NAMESPACE),
        memory=[MEMORY_FILE],
        middleware=[MemoryVisibilityMiddleware()],
    )

class MemoryVisibilityMiddleware(AgentMiddleware):
    """Republish `memory_contents` as a `custom` stream event.
 
    `PrivateStateAttr` keeps the key out of the `values` stream, which is right
    for a transcript and wrong for a panel. This is a demo-side shim: the key
    stays private on the state and is simply announced alongside it.
    """
 
    @property
    def name(self) -> str:
        return "MemoryVisibilityMiddleware"
 
    def _emit(self, state: dict[str, Any]) -> None:
        contents = state.get("memory_contents")
        if contents is None:
            return
        try:
            writer = get_stream_writer()
        except (RuntimeError, KeyError):
            # No streaming context. The value is still on the checkpoint, which
            # is what the client's history hydration reads.
            return
        writer({"name": MEMORY_EVENT, "data": {"memory_contents": contents}})
 
    def after_model(self, state: dict[str, Any], runtime: Any) -> None:  # noqa: ANN401, ARG002
        self._emit(state)
        return None
 
    def after_agent(self, state: dict[str, Any], runtime: Any) -> None:  # noqa: ANN401, ARG002
        self._emit(state)
        return None

import { injectCockpitRuntimeConnection } from '@threadplane/cockpit-telemetry';
import { ApplicationConfig } from '@angular/core';
import { provideAgent } from '@threadplane/langgraph';
 
export const appConfig: ApplicationConfig = {
  providers: [
    provideAgent(() => {
      const connection = injectCockpitRuntimeConnection();
      if (connection.adapter !== 'langgraph') {
        throw new Error('incompatible runtime');
      }
      return {
        apiUrl: connection.apiUrl,
        assistantId: connection.assistantId,
        clientOptions: connection.clientOptions,
      };
    }),
  ],
};

/** Latest `memory_contents` announced on the custom stream. */
private readonly liveMemory = computed<Record<string, string> | null>(() => {
  for (const event of [...this.agent.customEvents()].reverse()) {
    if (event.name !== MEMORY_EVENT) continue;
    const contents = (event.data as { memory_contents?: unknown } | undefined)?.[
      'memory_contents'
    ];
    if (contents && typeof contents === 'object') return contents as Record<string, string>;
  }
  return null;
});
 
/**
 * `memory_contents` off the hydrated thread state.
 *
 * The key is private to the `values` stream but is written to the
 * checkpoint, so this covers a reopened thread where no custom event has
 * fired in this session.
 */
private readonly settledMemory = computed<Record<string, string> | null>(() => {
  const contents = (this.agent.value() as Record<string, unknown> | undefined)?.[
    'memory_contents'
  ];
  return contents && typeof contents === 'object'
    ? (contents as Record<string, string>)
    : null;
});

/**
 * Which of the two sources the panel is currently showing.
 *
 * `live` means the graph's visibility middleware announced the key on the
 * custom stream during this run. `checkpoint` means only the settle-time
 * hydration has it — which is what a reopened thread looks like, and also
 * what the panel degrades to if the middleware is removed.
 */
protected readonly memorySource = computed<'live' | 'checkpoint' | 'none'>(() => {
  const live = this.liveMemory();
  if (live && Object.keys(live).length > 0) return 'live';
  return this.settledMemory() ? 'checkpoint' : 'none';
});

<div sidebar class="panel">
  <h3 class="cap">Agent Memory</h3>
  <p class="source" data-testid="memory-source" [attr.data-source]="memorySource()">
    {{ memorySource() === 'live' ? 'streamed live' : memorySource() === 'checkpoint' ? 'from checkpoint' : 'no source yet' }}
  </p>
  @if (memoryFiles().length === 0) {
    <p class="empty">Nothing remembered yet</p>
  }
  @for (file of memoryFiles(); track file.path) {
    <div class="mem" data-testid="memory-file" [attr.data-path]="file.path">
      <span class="mem__path">{{ file.path }}</span>
      @for (line of file.lines; track $index) {
        <p class="mem__line" data-testid="memory-line">{{ line }}</p>
      }
    </div>
  }
  <p class="hint">
    This file lives in the LangGraph store, not on the thread. Reload the page to start a
    new conversation and it will still be here.
  </p>
</div>