Skip to main contentSkip to footer
EsempioscriptintermediateEseguibilememory-lab

Memoria: archivia e recupera informazioni rilevanti tra le interazioni.

Questo componente mantiene la cronologia della conversazione e il contesto per abilitare interazioni coerenti su più turni.

Fatti chiave

Livello
intermediate • Blocchi di Costruzione degli Agenti
Runtime
Python • API OpenAI
Pattern
Assistenza consapevole della memoria con contesto leggibile
Interazione
Sandbox live • Script
Aggiornato
14 marzo 2026

Naviga questo esempio

Vista rapida del flusso

Come questo esempio si muove tra input, esecuzione e risultato rivedibile
Memoria: archivia e recupera informazioni… -> Store reusable memory -> Richiesta utente -> Esecuzione del sistema -> Output verificabile -> Progettare per la delega…

Trigger

Memoria: archivia e recupera informazioni…

Runtime

Store reusable memory

Esito

Richiesta utente

Perché esiste questa pagina

Questo esempio è mostrato sia come codice sorgente reale che come pattern di interazione orientato al prodotto, così i discenti possono collegare implementazione, UX e dottrina senza lasciare la libreria.

Flusso visivoCodice realeSandbox o walkthroughAccesso MCP
Come dovrebbe essere usato questo esempio nella piattaforma?

Usa prima la sandbox per comprendere il pattern di esperienza, poi ispeziona il sorgente per vedere come il confine del prodotto, il confine del modello e il confine della dottrina sono effettivamente implementati.

UX pattern: Assistenza consapevole della memoria con contesto leggibile
Progettare per la delega piuttosto che per la manipolazione diretta
Sostituire la magia implicita con modelli mentali chiari
Stabilire fiducia attraverso l'ispezionabilità
Riferimenti sorgente
Voce di libreria
agents-building-blocks-2-memory
Percorso sorgente
content/example-library/sources/agents/building-blocks/2-memory.py
Librerie
openai, requests
Requisiti di runtime
OPENAI_API_KEY
Principi correlati
Progettare per la delega piuttosto che per la manipolazione diretta, Sostituire la magia implicita con modelli mentali chiari, Stabilire fiducia attraverso l'ispezionabilità, Rendere espliciti i passaggi, le approvazioni e i blocchi, Ottimizzare per la guida, non solo per l'inizio

2-memory.py

python
"""
Memory: Stores and retrieves relevant information across interactions.
This component maintains conversation history and context to enable coherent multi-turn interactions.

More info: https://platform.openai.com/docs/guides/conversation-state?api-mode=responses
"""

from openai import OpenAI

client = OpenAI()


def ask_joke_without_memory():
    response = client.responses.create(
        model="gpt-4o-mini",
        input=[
            {"role": "user", "content": "Tell me a joke about programming"},
        ],
    )
    return response.output_text


def ask_followup_without_memory():
    response = client.responses.create(
        model="gpt-4o-mini",
        input=[
            {"role": "user", "content": "What was my previous question?"},
        ],
    )
    return response.output_text


def ask_followup_with_memory(joke_response: str):
    response = client.responses.create(
        model="gpt-4o-mini",
        input=[
            {"role": "user", "content": "Tell me a joke about programming"},
            {"role": "assistant", "content": joke_response},
            {"role": "user", "content": "What was my previous question?"},
        ],
    )
    return response.output_text


if __name__ == "__main__":
    # First: Ask for a joke
    joke_response = ask_joke_without_memory()
    print(joke_response, "\n")

    # Second: Ask follow-up without memory (AI will be confused)
    confused_response = ask_followup_without_memory()
    print(confused_response, "\n")

    # Third: Ask follow-up with memory (AI will remember)
    memory_response = ask_followup_with_memory(joke_response)
    print(memory_response)
Cosa dovrebbe ispezionare il discente nel codice?

Cerca il punto esatto in cui lo scope del sistema è delimitato: definizioni di schema, impostazione del prompt, configurazione di runtime e il punto di chiamata che trasforma l'intenzione dell'utente in un'azione concreta del modello o del workflow.

Cerca i contratti di output e la validazione
Cerca la chiamata di esecuzione esatta
Cerca cosa il prodotto potrebbe esporre all'utente
Come si relaziona la sandbox al sorgente?

La sandbox dovrebbe rendere leggibile l'UX: cosa vede l'utente, cosa sta decidendo il sistema e come il risultato diventa revisionabile. Il sorgente mostra poi come quel comportamento è effettivamente implementato.

Inserisci un messaggio o carica uno scenario memoria.
Esegui il recupero del contesto rilevante.
Rivedi sia la memoria richiamata sia la risposta personalizzata.
SandboxAssistenza consapevole della memoria con contesto leggibile
Laboratorio della memoria

Questa esperienza mette in evidenza che cosa il sistema ricorda, che cosa recupera e come quel contesto modifica la risposta all'utente.

Spiegazione UX

Gli esempi di memoria sono credibili solo quando l'utente può capire quali dati sono stati recuperati e perché influenzano la risposta.

Spiegazione AI Design

La memoria non è solo persistenza. È una scelta di prodotto su che cosa salvare, che cosa richiamare e come rendere ispezionabile l'effetto del contesto sul risultato.

Guida all'interazione

  1. 1Inserisci un messaggio o carica uno scenario memoria.
  2. 2Esegui il recupero del contesto rilevante.
  3. 3Rivedi sia la memoria richiamata sia la risposta personalizzata.

Messaggio

Memoria richiamataNuova memoria

Contesto richiamato

Il contesto richiamato appare qui.

Memoria da salvare

La memoria suggerita appare qui.

Risposta visibile

La risposta personalizzata appare qui.

Usato in corsi e percorsi

Principi correlati

Runtime architecture

Usa questo esempio nei tuoi agenti

Questo esempio è disponibile anche tramite il layer agent-ready del blueprint. Usa la pagina Per agenti per recuperare MCP pubblico, export deterministici e setup per Claude o Cursor.

Definisci trigger, contesto e confini prima di aumentare l'autonomia
Rendi espliciti controllo, osservabilita e recovery nel runtime
Scegli i pattern operativi giusti prima di delegare ai workflow