ExamplescriptintermediateRunnablememory-lab

Config

Runnable example (intermediate) for script.

Key Facts

Level: intermediate
Runtime: Python
Pattern: Memory-aware assistance with legible context
Interaction: Live sandbox • Script
Updated: 14 March 2026

Navigate this example

Library
Browse examples
Reopen the wider library to compare adjacent patterns and linked learning paths.
Interaction
Run sandbox now
Try the interaction directly in this example’s guided sandbox surface.
Source
Open full source
Read the real implementation, highlighted checkpoints, and runtime requirements.
MCP
Call via MCP
Use the same resource inside agents, deterministic exports, and MCP setup flows.

Linked principles

Ensure that background work remains perceptible Align feedback with the user’s level of attention Establish trust through inspectability

High-level flow

How this example moves from input to execution and reviewable output

Config -> User request -> System execution -> Reviewable output -> Ensure that background work… -> Align feedback with the…

Start

Config

Checkpoint

User request

Outcome

System execution

Why this page exists

This example is shown as both real source code and a product-facing interaction pattern so learners can connect implementation, UX, and doctrine without leaving the library.

Visual flowReal sourceSandbox or walkthroughMCP access

How should this example be used in the platform?

Use the sandbox to understand the experience pattern first, then inspect the source to see how the product boundary, model boundary, and doctrine boundary are actually implemented.

UX pattern: Memory-aware assistance with legible context

Ensure that background work remains perceptible

Align feedback with the user’s level of attention

Establish trust through inspectability

Source references

Library entry: knowledge-mem0-oss-config
Source path: content/example-library/sources/knowledge/mem0/oss/config.py
Libraries: None listed
Runtime requirements: Local repo environment
Related principles: Ensure that background work remains perceptible, Align feedback with the user’s level of attention, Establish trust through inspectability

config.py

content/example-library/sources/knowledge/mem0/oss/config.py

python

config = {
    "vector_store": {
        "provider": "qdrant",
        "config": {"host": "localhost", "port": 6333},
    },
    "llm": {
        "provider": "openai",
        "config": {"api_key": "your-api-key", "model": "gpt-4"},
    },
    "embedder": {
        "provider": "openai",
        "config": {"api_key": "your-api-key", "model": "text-embedding-3-small"},
    },
    "graph_store": {
        "provider": "neo4j",
        "config": {
            "url": "neo4j+s://your-instance",
            "username": "neo4j",
            "password": "password",
        },
    },
    "history_db_path": "/path/to/history.db",
    "version": "v1.1",
    "custom_fact_extraction_prompt": "Optional custom prompt for fact extraction for memory",
    "custom_update_memory_prompt": "Optional custom prompt for update memory",
}

What should the learner inspect in the code?

Look for the exact place where system scope is bounded: schema definitions, prompt framing, runtime configuration, and the call site that turns user intent into a concrete model or workflow action.

Look for output contracts and validation

Look for the exact execution call

Look for what the product could expose to the user

How does the sandbox relate to the source?

The sandbox should make the UX legible: what the user sees, what the system is deciding, and how the result becomes reviewable. The source then shows how that behavior is actually implemented.

Enter a message or load a memory scenario.

Run the context recall step.

Inspect both the recalled memory and the personalized reply.

SandboxMemory-aware assistance with legible context

Memory lab

This experience makes it clear what the system remembers, what it retrieves, and how that context changes the reply.

UX explanation

Memory examples are only trustworthy when the user can understand which information was recalled and why it changes the response.

AI design explanation

Memory is not just persistence. It is a product choice about what to store, what to recall, and how to make the effect of context inspectable.

Interaction walkthrough

1Enter a message or load a memory scenario.
2Run the context recall step.
3Inspect both the recalled memory and the personalized reply.

Principles in focus

Ensure that background work remains perceptible Align feedback with the user’s level of attention Establish trust through inspectability

Message

Recalled memoryNew memory

Recalled context

The recalled context appears here.

Memory to store

The suggested memory write appears here.

Visible reply

The personalized reply appears here.

Used in courses and paths

This example currently stands on its own in the library, but it still connects to the principle system and the broader example family.

Related implementation patterns

Related principles

Runtime architecture

Use this example in your agents

This example is also available through the blueprint’s agent-ready layer. Use the For agents page for the public MCP, deterministic exports, and Claude/Cursor setup.

Define triggers, context, and boundaries before increasing autonomy

Make control, observability, and recovery explicit in the runtime

Choose the right operational patterns before delegating to workflows

Open For agents