GODRICH
#css애니메이션#버튼#로딩#전환효과#스크롤#대시보드#실전ui#디자인트렌드

n8n ai agent memory 9종 — 세션 슬롯·장기기억·압축

메모리는 저장이 아니라 예산이다 — 세션 슬롯은 턴이 쌓일 때마다 윈도우 감쇠 α=0.72 로 밀리고, 장기기억은 승격 임계 3회 도달 턴만 남는다. 세션 ID 하나로 갈리는 맥락 유지·소거·복원을 LLM 없이 규칙 계산으로 재현하는 9종이다.

zip 구성과 여는 법

AI 에이전트 메모리 9종 — 타임라인·설정·before/after·슬롯·장기기억·압축·소거·중복 제거·복원

공용 엔진 한 겹이 아홉 장면을 돌린다

아홉 장면은 각자 그리지 않는다 — 2초 24프레임 주기의 WAAPI 시계, 재생할 때마다 같은 값을 내는 시드 고정 난수 seedHash, 일시정지·되감기·프리셋 전환 분기가 공용 몸통이고(도구 루프를 연 n8n ai agent 도구 루프 9종의 core 엔진 계승), 그 위에 이 편의 주역 계산이 얹힌다. 예산을 넘은 턴 높이를 오래된 순서로 감쇠시키는 memDecay, 토큰 겹침으로 재등장을 판정하는 jac, 편집 거리로 같은 질문을 합치는 levDist, 키 문자열을 0~1 로 접는 keyHash, 요약 뒤 남는 높이를 정하는 압축비까지 — 메모리의 채움·밀림·승격·중복 판정·압축이 전부 이 다섯 계산에서 나오므로 외부 LLM 호출은 한 번도 없다.

    // MEM_DECAY — 예산 초과 시 오래된 턴 높이를 alpha^k 로 감쇠 (04의 주역 계산)
    function memDecay(heights, budget, alpha) {
        let total = 0;
        for (let i = 0; i < heights.length; i += 1) { total += heights[i]; }
        const out = heights.slice();
        let k = 0;
        let idx = 0;
        while (total > budget && idx < out.length) {
            out[idx] = heights[idx] * Math.pow(alpha, k + 1);
            total = 0;
            for (let i = 0; i < out.length; i += 1) { total += out[i]; }
            k += 1;
            idx += 1;
        }
        return out;
    }

jac 는 두 턴의 토큰 교집합을 합집합으로 나눈 자카드 겹침이고 levDist 는 삽입·삭제·교체를 각 1로 세는 동적 계획 편집 거리다 — 이 두 함수의 산술은 05·06 절에서 검산하고, keyHash 와 압축비는 02·07 절에서 계산해 본다.

데모는 n8n 실행 실측이 아니라 교육용 규칙 근사다

먼저 경계를 적는다 — 이 데모의 감쇠·승격·중복 판정·압축은 n8n 을 실제로 실행해 잰 값이 아니라, n8n 공식 문서에 적힌 메모리 동작을 교육용 규칙 계산으로 재현한 주입 시연이다. AI Agent 노드에 Memory 서브노드를 붙여 턴마다 대화 맥락을 읽고 쓰며, Simple Memory 가 세션 키로 대화를 구분하고 Window Buffer Memory 가 최근 N턴만 유지한다는 점, 그리고 Postgres Chat Memory · MongoDB Chat Memory · Redis Chat Memory 같은 백엔드 노드가 실제로 있다는 점은 n8n 공식 문서에 근거한다. 반면 감쇠 곡선 α=0.72 · 자카드 임계 0.34 · 압축비 0.55 는 이 데모의 계산이지 n8n 내부 구현이 아니다 — 실제 n8n 의 Window Buffer Memory 는 설정한 컨텍스트 길이 그대로 최근 턴을 유지할 뿐 자동 감쇠 곡선을 돌리지 않고, 요약 압축도 연결된 챗 모델과 서브노드 구현이 결정한다. 값이 실제와 다를 수 있음을 먼저 전제한다.

모델과 실측의 경계

숫자도 갈라 적는다 — 예산 360 · 감쇠 α 0.72 · 승격 임계 3회 · 편집 거리 임계 6 · 복원 4 × 300 = 1,200ms 처럼 소스 상수에서 계산하거나 검산한 값은 모델이고, 면적·강도·프레임은 렌더러가 2초 회차를 스물네 컷으로 남기고 붙은 두 컷의 차 스물세 개로 잰 실측이다. 누적면적은 회차 창 안에서 첫 컷과 달라진 적이 한 번이라도 있는 화소 비율, 강도는 변화 화소의 밝기·색차 평균(0~255 척도)이며 렌더 지터로 ±0.1 흔들린다.

측정 정답표

주입 시연 회차로 아홉 장면을 돌려 남긴 숫자가 아래 값이다 — 씬 배경을 진행 값이 좌에서 우로 순회하는 배경 sweep 이 면적의 주 확보원이고, 아홉 장면 전부 창 내내 움직였다.

장면 누적면적 움직인 프레임 강도 평균
01 대화 타임라인 경로 36.5% 23/23 90.3
02 메모리 노드 설정 35.7% 23/23 99.5
03 읽기·쓰기 JSON diff 35.9% 23/23 106.3
04 슬롯 채움과 감쇠 35.4% 23/23 106.8
05 장기기억 승격 32.5% 23/23 122.8
06 중복 제거 히트맵 28.4% 23/23 126.9
07 요약 압축 예산 34.1% 23/23 108.0
08 세션 전환 소거 33.4% 23/23 105.5
09 세션 복원 32.8% 23/23 83.6

면적이 가장 넓은 것은 01 의 36.5% 이고 가장 좁은 것은 06 의 28.4% 다 — 히트맵 셀의 색 전환이 배경 sweep 과 겹치는 픽셀 폭이 다른 장면보다 좁아서다. 강도는 06 의 126.9 가 가장 높은데 히트맵 칸이 임계 안팎에서 톤을 확 바꾸는 컷이 겹쳐서고, 09 의 83.6 이 가장 낮은 것은 복원 이동이 완만한 이징으로 진행되어 프레임당 변화가 작기 때문이다. 순간 최대 면적(요소 자체 움직임만 잰 값)은 02 의 8.6% · 01 의 3.7% · 09 의 2.4% 순이고, 넘침·320px 폭 넘침·로케일 넘침은 전 씬 0건, react 판은 TypeScript 컴파일 9파일·SCSS 단독 컴파일 9파일 전부 통과했다.

아홉 장면이 이 순서인 이유

순서는 메모리를 실제로 다루는 흐름을 따라간다 — 대화가 어떤 경로로 메모리에 흐르는지 보고(01), 노드 설정이 무엇을 고정하는지 확인하고(02), 한 턴이 상태를 무엇으로 바꾸는지 데이터로 보고(03), 슬롯이 차오르고 밀리는 법(04), 장기기억으로 올라가는 턴(05), 같은 질문이 쌓이지 않게 하는 판정(06), 예산을 넘었을 때의 요약(07)을 지나, 세션 전환으로 지워지는 것(08)과 세션 ID 로 다시 열리는 복원(09)으로 끝난다. n8n 축의 첫 모음 n8n 워크플로우 예제 9종이 데이터 흐름이었다면, 도구 루프 편이 그 위에 도는 에이전트였고, 이번 편은 그 에이전트가 턴 사이에 기억을 어떻게 들고 다니는지를 같은 문법으로 연 것이다.

01대화 타임라인은 어떻게 메모리로 흘러가나 — 턴마다 세션 키가 가르는 경로

좌측 채팅 타임라인의 턴 버블이 sess-A · sess-B 두 세션 키로 갈라져 우측 메모리 박스 두 개로 흘러 들어가고 각 턴은 자기 경로 위를 주행하며 도착한 박스의 미니 슬롯을 순서대로 채우고 지금 흐르는 턴이 어느 세션인지 배지가 밝힌다 — 실제 n8n 의 Simple Memory 가 Session ID 로 대화를 구분하는 동작을 키가 경로를 가른다는 그림으로 옮긴 장면이고 한눈에 흐름을 보여 주는 역할만 한다.

대화 타임라인 — 턴이 세션 키로 갈라져 메모리로 흐르는 경로
전체 코드 새 창에서 열기

01 · 대화 타임라인 — 턴이 세션 키로 갈라져 메모리로 흐르는 경로 — 측정 누적면적 36.505% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기

turnFlowsessKeynd--on

턴 배치와 주행은 상수 다섯 개다

턴 다섯 개는 340ms 간격으로 등장해 240ms 동안 경로를 주행하고 sess-A 소속 턴은 위쪽 메모리 박스 · sess-B 소속 턴은 아래쪽 박스의 슬롯을 채우며, 복붙해 쓸 때는 TURNS01 의 세션 표기와 문장을 자기 대화 로그로 바꾸고 SESS01 의 키 이름을 자기 Session ID 값으로 바꾸면 경로 분기가 그대로 자기 워크플로가 된다.

    const SESS01 = ['sess-A', 'sess-B'];
    const TURNS01 = [
        ['A', '주간 보고 초안 잡아 줘'],
        ['A', '비용 계산해 줘'],
        ['B', '다른 주제인데 번역해 줘'],
        ['A', '보고 마저 이어서'],
        ['B', '번역 톤 다시 맞춰 줘']
    ];

같은 화면에서 여러 세션의 메모리가 섞이지 않는 이유는 sk 가 턴마다 키로 갈린 인덱스 하나만 남기고 나머지 박스는 채움을 0 으로 되돌리기 때문이다.

02메모리 노드 설정 패널은 무엇을 고정하나 — 세션 ID 키·윈도우 크기·컨텍스트 길이

설정 패널의 네 항목 Session ID Key · Session ID Value · Context Window Length · Session Time to Live 에 원형 게이지가 차오르고 포커스 링이 460ms 주기로 항목 사이를 순회하며, 세션 키 칸의 게이지는 키 문자열의 글자 코드를 접어 0~1 로 정규화해 채운다 — 키가 곧 메모리의 서랍 주소라는 관점이 이 장면의 주장이고 설정은 취향이 아니라 메모리가 쓸 예산의 정의라는 시각에 윈도우 길이를 늘리면 토큰 비용이 그만큼 늘어난다는 읽는 법까지 붙는다.

메모리 노드 설정 패널 — Session ID · 윈도우 크기 · 컨텍스트 길이
전체 코드 새 창에서 열기

02 · 메모리 노드 설정 패널 — Session ID · 윈도우 크기 · 컨텍스트 길이 — 측정 누적면적 35.699% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기

settingsPanelgwrapkeyHash

keyHash 검산 — sessionId 는 0.75 를 가리킨다

keyHash 는 글자 코드를 h = h×31 + code 로 접고 997 으로 나눈 나머지를 0~1 로 정규화하는데 검산하면 keyHash('sessionId') = 751/997 ≈ 0.75 · keyHash('user-42') ≈ 0.69 이고 화면의 두 게이지 채움이 이 값에서 명목 구간(0.6~1.0 · 0.45~0.95)으로 사상된다 — 임베딩 없이 문자열 하나가 서랍 주소 하나로 대응되는 것을 계산으로 보이는 장치다.

        // keyHash — 글자 코드 접기 (계산 한 겹: 문자열 -> 0-1)
        function keyHash(s) {
            let h = 0;
            for (let c = 0; c < s.length; c += 1) { h = (h * 31 + s.charCodeAt(c)) % 997; }
            return h / 997;
        }
        const vals = [keyHash('sessionId') * 0.6 + 0.4, keyHash('user-42') * 0.5 + 0.45, 5 / 8, 0.72];

31 과 997 은 해시 접기의 관례값이라 다른 값으로 바꿔도 규칙은 성립하지만 같은 키가 반드시 같은 게이지를 가리켜야 한다는 성질은 남아야 하고, 실전에서 Session ID 키를 사용자 ID · 채팅방 ID 같은 안정 값으로 잡는 이유가 이 규칙성이다 — 값이 흔들리면 09 의 복원이 아예 성립하지 않는다.

03메모리 슬롯은 어떻게 채워지고 밀리나 — 한 턴이 JSON 에 남기는 한 줄

메모리 읽기·쓰기의 before/after 를 세로로 흘리며 바뀐 줄만 jl--diff 로 밝히는데 한 턴의 쓰기는 직렬화된 messages 배열 끝에 정확히 한 줄을 붙이고 읽기는 배열 전체를 컨텍스트로 반환한다 — 쓰기는 O(1) 이고 읽기는 O(n) 이라는 비용의 비대칭이 데이터로 보이고 턴 하나가 상태를 무엇으로 바꾸는지 확인하는 장이다.

메모리 읽기·쓰기 전후 JSON diff
전체 코드 새 창에서 열기

03 · 메모리 읽기·쓰기 전후 JSON diff — 측정 누적면적 35.94% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기

slotWritejl--diffshallowLines

바뀐 줄 판정은 얕은 비교 한 줄이다

바뀐 줄은 두 직렬화 객체를 줄 단위로 놓고 마지막 붙은 줄만 대조해 찾으며 changed n 배지가 이 집계를 상시 남기고 2초 주기의 앞 1초는 쓰기 · 뒤 1초는 읽기 국면으로 나뉘어 한 주기에 두 동작을 다 보여 주고 프리셋이 바뀌면 붙는 턴이 바뀌어 messages 행수가 매번 다시 계산된다 — 읽기 국면에서 before 패널이 jl--dim 으로 낮아지는 대비가 실제 n8n 의 메모리 조회 로그 모양을 유지하게 한다.

    const MSG03 = [
        ['user: 보고 초안 잡아 줘', 'ai: 3단 구조로 잡았다'],
        ['user: 두 번째 섹션 늘려 줘', 'ai: 근거 2개를 더했다'],
        ['user: 요약 한 줄로 줄여 줘', 'ai: 첫 문장 하나로 압축했다']
    ];
    let cols03 = null;
    let badge03 = null;
    let mode03 = null;
    function shallowLines(arr, extra) {
        const out = ['{', '  "messages": ['];
        for (let k = 0; k < arr.length; k += 1) {
            out.push('    "' + arr[k][0].slice(0, 20) + '"');
            out.push('    "' + arr[k][1].slice(0, 20) + '"');
        }
        if (extra) { out.push('    "' + extra.slice(0, 20) + '"'); }
        out.push('  ]');
        out.push('}');
        return out;
    }

복붙 포인트는 MSG03 을 자기 대화 로그로 채우는 것이다.

04슬롯이 차오르면 무엇이 밀리나 — 윈도우 크기와 지수 감쇠

세로 6칸 슬롯에 턴이 도착할 때마다 토큰 높이만큼 채워지고 총높이가 예산 360 을 넘으면 오래된 슬롯부터 높이 × 0.72^k 로 낮아진다 — 밀려난 슬롯은 점선 윤곽만 남고 감쇠 총합은 매턴 재계산되어 예산선 위로 넘지 않는다 — n8n ai agent memory chat window 의 최근 N턴 유지가 이 윈도우 개념의 원형이고 채움과 밀림을 설명하는 용도로 쓴다.

슬롯 채움과 밀림 — 윈도우 크기와 지수 감쇠
전체 코드 새 창에서 열기

04 · 슬롯 채움과 밀림 — 윈도우 크기와 지수 감쇠 — 측정 누적면적 35.412% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기

turnbarDECAY_ALPHAbudgetline

검산 — 406 은 세 턴 감쇠로 316.0 이 된다

턴 높이 [64, 56, 72, 68, 76, 70] 의 총합 406 이 예산 360 을 넘으면 첫 턴 64 가 64 × 0.72 = 46.1 (총 388.1), 둘째 턴 56 이 × 0.72² = 29.0 (총 361.0), 셋째 턴 72 가 × 0.72³ = 26.9 (총 316.0 ≤ 360) 에서 정지하는데 이때 세 턴이 감쇠되고 예산선 아래로 내려온다 — 감쇠 지수 k 는 오래된 턴부터 차례로 붙으므로 아주 오래된 턴은 사실상 0 에 수렴한다.

    const H04 = [64, 56, 72, 68, 76, 70]; // 턴 토큰 높이 (총 406 — 4턴째 68 에서 360 예산 초과로 감쇠 발동)
    function frame(t) {
        const ph = demoT(t) / 2000;
        const shown = clamp(Math.floor(ph * 8) + 1, 1, 6); // 8단계로 6턴 등장
        const hs = [];
        for (let k = 0; k < shown; k += 1) { hs.push(H04[k]); }
        const dec = memDecay(hs, 360, DECAY_ALPHA);
        let tot = 0;
        for (let k = 0; k < dec.length; k += 1) { tot += dec[k]; }

실전의 Window Buffer Memory 가 이 감쇠 대신 최근 N턴을 통째로 남기는 하드 컷을 쓴다는 점은 위의 근사 고지 그대로이고 하드 컷으로 바꾸려면 memDecay 의 while 문을 배열 슬라이스 한 줄로 바꾸면 되며 감쇠를 느리게 하는 변형은 아래 값 조절 절에서 검산한다.

05어떤 턴이 장기기억으로 승격되나 — 재등장 횟수 임계와 승격 규칙

각 주제 턴의 재등장 횟수가 세로 게이지에 오르고 PROMOTE_N(3) 에 도달한 턴에서만 장기기억 영역으로 승격 화살표가 발사되며 미달 턴은 윈도우 감쇠로 사라지고 승격된 턴은 감쇠 없이 남는다 — 재등장 판정은 토큰 겹침, 즉 자카드 0.34 이상으로 계산되므로 같은 주제를 다른 말로 물어도 잡히고 어떤 턴이 장기기억으로 올라가는지 보여 준다.

장기기억 승격 — 재등장 횟수 임계와 승격 화살표
전체 코드 새 창에서 열기

05 · 장기기억 승격 — 재등장 횟수 임계와 승격 화살표 — 측정 누적면적 32.451% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기

promoteNjacmslot--ltm

검산 — 세 주제의 seen 은 3·2·1 이다

주제 토큰이 [보고, 초안, 구조] · [비용, 계산] · [번역, 톤] 이면 첫 주제는 3/3 에 도달해 승격하고 둘째 2/3 · 셋째 1/3 은 미달로 윈도우 감쇠 대상이 되어 화면의 승격 화살표는 seen ≥ 3 인 주제에서만 발사된다 — 자카드 임계 0.34 는 「보고 초안 구조 잡기」와 「보고 초안 다시 잡아 줘」처럼 핵심 명사가 둘 이상 겹치는 재등장은 잡고 「보고 초안」과 「메일 초안」처럼 한 단어만 겹치는 우연은 놓치는 값이다.

    // JAC — 두 토큰 배열의 자카드 겹침(교집합/합집합). 05의 승격 판정이 쓴다
    function jac(a, b) {
        let hit = 0;
        for (let i = 0; i < a.length; i += 1) {
            if (b.indexOf(a[i]) >= 0) { hit += 1; }
        }
        const uni = a.length + b.length - hit;
        return uni > 0 ? hit / uni : 0;
    }

실전의 n8n ai agent long term memory 는 이런 규칙 판정 대신 벡터 저장소 기반 검색을 쓰는 것이 보통이라 이 장면은 임계와 승격의 구조를 보여 주는 근사이고 임계를 낮추는 변형은 값 조절 절에서 검산한다.

06같은 질문이 쌓이면 어떻게 하나 — 레벤슈타인 거리의 중복 제거

들어온 질문과 기존 슬롯 질문 사이의 레벤슈타인 거리를 계산해 임계 6 이하면 같은 질문으로 합치는데 거리 행렬이 히트맵으로 그려지고 합쳐질 질문 쌍에 연결선이 생긴 뒤 슬롯 카운트만 오르고 줄은 늘지 않는다 — 메모리 절약이 계산으로 증명되는 씬이고 같은 질문이 쌓이는 것을 막는 판정이 여기 드러난다.

중복 제거 — 레벤슈타인 거리로 같은 질문 합치기
전체 코드 새 창에서 열기

06 · 중복 제거 — 레벤슈타인 거리로 같은 질문 합치기 — 측정 누적면적 28.4% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기

levDisthcellhnum

검산 — 거리 1·3은 합치고 5 이상은 놓아둔다

들어온 「비용 계산해 줘」와 저장된 「비용 계산해 줘」는 거리 0, 「비용 계산해 줘」↔「비용을 계산해 줘」는 조사 「을」 삽입 1, 「보고 초안 잡아 줘」↔「보고 초안 만들어 줘」는 「잡아」↔「만들어」 교체 3 으로 전부 임계 6 이하라 합쳐지고 「번역 톤 맞춰 줘」↔「번역해 줘」의 5 도 임계 안이라 대각선 네 칸에 합침 판정이 걸리는 반면 「번역 톤 맞춰 줘」↔「보고 초안 만들어 줘」의 7 · ↔「비용 계산해 줘」의 6 은 대각선 밖이라 별개 질문으로 남는다 — 임계 6 을 글자 수로 환산하면 조사 하나(1)와 짧은 서술어 교체(3)까지는 같은 질문으로 보고 주제어가 바뀌는 7 이상은 별개 질문으로 남긴다는 뜻이다.

    const Q06 = [
        ['보고 초안 잡아 줘', '보고 초안 만들어 줘', 2],
        ['비용 계산해 줘', '비용을 계산해 줘', 1],
        ['번역해 줘', '요약해 줘', 2]
    ];
    let cells06 = null;
    let nums06 = null;
    let incoming06 = null;
    let stored06 = null;
    const DEDUPE_T = 6;

이 판정이 없으면 같은 질문이 행을 계속 늘려 04 의 예산을 불필요하게 태우고 n8n 에 이 규칙에 딱 대응하는 노드 설정은 없으므로 실전에서는 사용자 발화를 정규화하는 Code 노드를 메모리 앞에 두는 것이 이 장면의 대응이다.

07요약 압축은 언제 일어나나 — 컨텍스트 예산 초과와 압축비 계산

턴 토큰 막대가 쌓여 예산 360 을 넘으면 오래된 그룹이 요약 막대 하나로 합쳐지는데 압축비는 COMPRESS_KEEP(0.55) 로 남는 높이가 결정하고 압축 후 총높이는 매번 다시 계산되어 예산선 위로 넘지 않는다 — 몇 턴이 요약되는지는 예산 초과분이 정한다는 것이 이 장면의 계산이고 예산을 넘은 메모리가 요약으로 줄어드는 계산이 여기 드러난다.

요약 압축 — 컨텍스트 예산 초과와 압축비 계산
전체 코드 새 창에서 열기

07 · 요약 압축 — 컨텍스트 예산 초과와 압축비 계산 — 측정 누적면적 34.085% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기

compressKeeptokbarbudgetline

검산 — 396 은 두 턴 접기로 357.6 이 된다

턴합 396 > 360 이므로 첫 턴 64 를 접으면 396 − 64 + 64 × 0.55 + 12 = 379.2 인데 아직 초과라 둘째 턴 48 도 접으면 379.2 − 48 + 48 × 0.55 + 12 = 357.6 ≤ 360 에서 정지해 두 턴이 요약되고 요약 오버헤드 12 토큰이 붙는다 — 요약은 공짜가 아니어서 접은 토큰이 줄어 55% 남더라도 요약 막대 자체가 12 토큰을 다시 차지하므로 턴 하나만 접는 압축은 오히려 이득이 없는 경우도 생긴다.

    const COMPRESS_KEEP = 0.55;
    const TURNS07 = [64, 48, 72, 58, 66, 88]; // 턴 토큰 (총 396 — 6턴째 88 에서 예산 360 초과로 압축 발동)
    let bars07 = null;
        if (over) {
            // 예산 초과분만큼 앞쪽 턴을 요약에 넣는다 — 압축 후 총 = (접은 토큰 x KEEP + 12) + 나머지
            let rest = raw;
            let k = 0;
            while (rest > 360 && k < shown - 1) {
                folded += TURNS07[k];
                rest = raw - folded + folded * COMPRESS_KEEP + 12;
                k += 1;
            }
            total = rest;
        }

이 while 문이 초과분이 사라질 때까지 연이어 접는 이유가 위의 오버헤드 계산이고 남는 45% 가 무엇인지는 함정 절에서 다시 본다.

08메모리 소거는 무엇을 지우나 — 세션 전환과 남는 흔적

세션 전환 이벤트가 도착하면 윈도우 슬롯 5칸이 위에서부터 순차적으로 지워지고 장기기억 슬롯은 그대로 남는데 각 칸 지움은 340ms 구간으로 계산되어 전체 1,700ms 걸리고 지워진 자리에 새 세션 ID 배지가 뜨며 TTL 카운터가 리셋된다 — 지워지는 것과 남는 것의 경계가 한 장으로 정리되고 clear 가 무엇을 지우는지 여기 드러난다.

메모리 소거 — 세션 전환과 남는 흔적
전체 코드 새 창에서 열기

08 · 메모리 소거 — 세션 전환과 남는 흔적 — 측정 누적면적 33.428% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기

clearEvtcsegnd--fail

지움 시간과 경계는 계산이다

프리셋마다 from 이 sess-A · sess-B · sess-C 로 바뀌어 같은 지움 규칙이 어떤 세션에서도 동일하게 돌아가는 것을 보여 주는데 윈도우는 키가 바뀌면 통째로 지워지지만 장기기억은 키와 무관하게 유지된다 — 장기기억이 지움에서 면제되는 경계가 실무에서 중요한 이유는 clear 를 불러도 기억이 다 지워졌다고 믿는 착각 때문이다.

    // 533-08 clear-session-switch — 세션 전환 이벤트가 윈도우 슬롯을 위→아래 순차 지움(clearEvt,
    // 칸당 340ms 구간)하고 장기기억은 남긴다. 새 세션 배지가 뜨고 TTL 카운터가 리셋된다.
        const CLEAR_AT = 0.28; // 세션 전환 이벤트 시점
        const CELL_MS = 340 / 2000; // 칸당 340ms 를 주기 비율로
        const wiped = ph < CLEAR_AT ? 0 : clamp(Math.floor((ph - CLEAR_AT) / CELL_MS) + 1, 0, 5);
        for (let k = 0; k < 5; k += 1) {
            const gone = k < wiped;
            cells08[k].className = cx('mslot' + (gone ? ' mslot--ghost' : ''));
            cells08[k].style.height = gone ? '56px' : '56px';
            cells08[k].style.opacity = gone ? '1' : '1';
        }

n8n ai agent clear memory 로 지워지는 것은 해당 세션 키의 대화 창이고 별도 저장소에 쌓은 요약이나 벡터는 자기 캐시를 비워야 사라지며 소거 시각 340 × 5 = 1,700ms 는 계산된 값이지 실제 n8n 의 삭제 지연이 아니라는 점도 위의 근사 고지 그대로다.

09세션 ID 로 메모리는 어떻게 다시 열리나 — 복원과 이어지는 턴

이전 세션 ID 배지가 다시 선택되면 백업 슬롯 네 개가 원래 위치로 되돌아오고 이어지는 새 턴이 복원된 슬롯 꼭대기에 쌓이는데 복원 이동은 복원 턴 수 × TURN_MS 로 계산되고 restored 4 turns 배지가 복원 흔적을 남긴다 — 세션 ID 가 곧 재개 장치라는 결론 장이고 세션 키로 메모리가 다시 열리는 순간을 보여 준다.

세션 복원 — 이전 대화로 돌아와 이어지는 턴
전체 코드 새 창에서 열기

09 · 세션 복원 — 이전 대화로 돌아와 이어지는 턴 — 측정 누적면적 32.847% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기

resumeTrslotTURN_MS

복원 시간은 4 × 300 = 1,200ms 다

RESTORE_N 4개 슬롯이 슬롯마다 0.08 위상 간격으로 순차 복귀해 전체 이동이 주기의 62% 구간에서 끝나고 복원 배지의 숫자는 이 진행을 세다가 4 에서 확정된다 — 복원은 과거를 감상하는 것이 아니라 그 위에 다음 턴을 올리는 것이므로 02 의 keyHash 가 같은 키는 같은 주소를 가리킨다는 규칙성을 지킬 때만 성립한다.

    // 533-09 restore-session-resume — 이전 세션 배지를 다시 선택하면 백업 슬롯이 원위치로
    // 복원되고(resumeT = 복원 턴 수 x TURN_MS) 이어지는 새 턴이 복원 슬롯 위에 쌓인다.
    const TURN_MS = 300;
    function frame(t) {
        const ph = demoT(t) / 2000;
        const TRAVEL = 0.62; // 복원 이동이 끝나는 시점 비율
        for (let k = 0; k < RESTORE_N; k += 1) {
            const sl = r09[k * 2];
            const lb = r09[k * 2 + 1];
            const dly = k * 0.08;
            const p = clamp((ph - dly) / (TRAVEL - dly), 0, 1);

세션 키 설계가 흔들리면 복원은 첫 장면의 경로 분기부터 무너진다.

메모리 데모가 깨지는 함정 — 영구 기억 가정·슬롯 무한 증가·요약 정보 손실

영구 기억을 가정하면 비용이 선형으로 자란다

윈도우 메모리는 예산을 넘으면 오래된 턴부터 잡아먹힌다 — 04 에서 감쇠가 없다면(예산 무한) 토큰 비용이 턴마다 선형으로 증가하는데, n8n ai agent session id 를 고정해 두고 대화만 길어지는 상황이 정확히 이 그림이다. 에이전트가 전 대화를 기억한다는 가정이 첫 함정이다.

슬롯 무한 증가는 중복 판정 없이 온다

같은 질문을 중복 판정 없이 그대로 쌓으면 행이 계속 늘어난다 — 06 의 레벤슈타인 임계가 줄을 늘리지 않고 카운트만 올리는 근거고, 사용자가 같은 요청을 조사만 바꿔 반복하는 실제 패턴에서는 이 판정이 없는 순간 예산이 새 질문이 아니라 복제질문으로 소진된다.

요약 압축만 믿으면 세부가 사라진다

07 의 압축비 0.55 는 45% 를 버린다는 뜻이다 — 압축 후 막대가 예산 안으로 들어와도 접힌 턴의 수치·이름 같은 세부는 남는 55% 에 없고, 요약 오버헤드 12 토큰까지 다시 지불한다. 남는 정보와 손실을 함께 보여 주는 이유다. 이 zip 의 잠금을 푸는 비밀번호는 ngj9cq4g 이고, 압축을 풀면 아홉 장면의 index.html · style.scss · style.css 와 react 판 전부가 그대로 들어 있다. 실전에서 먼저 할 일은 지울 턴을 고르는 기준을 정하는 것 — 이 데모는 오래된 순서로 접지만 자기 서비스라면 주제별 대표 턴만 남기는 식으로 바꿀 수 있고, 접는 함수의 while 문 한 곳이 그 기준이 사는 자리다. 이 데모가 n8n 실측이 아니라 교육용 규칙 근사라는 경계를 한 번 더 적는다 — 노드명과 세션 키·윈도우 구조는 공식 문서 근거지만 감쇠·자카드·레벤슈타인·압축비 값은 이 데모의 계산이다.

메모리 시각화는 어디에 쓰나 — 세션 대시보드·디버거·교육 자료

이 아홉 장면이 실무에 닿는 갈래는 세 가지다. 첫째 세션 대시보드 — 01 의 경로와 08 의 소거 상태를 붙이면 지금 몇 개 세션이 살아 있고 각 키에 턴이 얼마나 쌓였는지가 한 화면에 잡힌다. 둘째 디버거 — 03 의 before/after diff 는 한 턴이 메모리를 무엇으로 바꿨는지, 05 의 승격 게이지는 장기기억이 안 쌓이는 고장을 잡는 시야다. 셋째 교육 자료 — 04 의 감쇠와 07 의 압축은 n8n ai agent chat memory 를 처음 설명할 때 노드 스크린샷보다 앞서 들 수 있는 그림이다. 실전 레시피를 찾는다면 n8n 워크플로우 예제 9종의 자료 모음 편이 이 축의 시작점이고, 반복 실행과 결과 리포트는 반복 업무 자동화가 잇는다.

실전에 붙일 때 고치는 곳은 문자열 상수 자리다 — 01 의 프리셋 대화를 챗 트리거 입력으로, 02 의 키를 자기 Session ID 키로, 06 의 질문 쌍을 자기 서비스의 자주 묻는 질문으로 연결하면 계산 구조는 그대로 두고 데이터만 실서비스 것이 된다. n8n ai agent memory mongodb 나 postgresql 로 백엔드를 옮기는 상황에서도 이 그림의 키·윈도우·소거·복원 경계는 그대로 유효하다 — 바뀌는 것은 슬롯이 사는 곳이지 슬롯의 규칙이 아니다. 각 장면은 Space 로 멈추고 R 로 되감고 방향키로 프리셋을 바꿔 검증할 수 있다.

값을 세 가지만 바꾸면 메모리의 성격이 어떻게 달라지나

상수를 한 곳씩만 움직여 본 세 가지다 — 계산 구조는 그대로 두고 감쇠·임계·압축비 중 하나만 옮긴다.

이름 바꾼 값 느낌
감쇠를 느리게 s04 DECAY_ALPHA 0.72 → 0.88 오래된 턴이 완만한 곡선으로 천천히 낮아져 슬롯이 반투명 상태로 오래 버틴다 — 검산하면 같은 406 을 세 턴이 아니라 네 턴에 걸쳐 335.5 로 내려온다
승격 임계를 낮춰 s05 PROMOTE_N 3 → 2 두 번째 재등장에서 곧장 장기기억으로 승격한다 — 화살표가 두 배 자주 발사되고 장기기억 슬롯이 빨라진 속도만큼 채워진다
압축비를 세게 s07 COMPRESS_KEEP 0.55 → 0.3 검산하면 두 턴(64+48=112)을 함께 접어 396 − 112 + 112 × 0.3 + 12 = 329.6 ≤ 360 — 접는 턴 수는 0.55 판과 같은 2개지만 남는 정보가 절반 가까이로 준다

첫 값은 밀림의 속도, 둘째는 장기기억의 문턱, 셋째는 손실의 크기를 각각 지배한다 — 세 가지를 함께 움직이면 어떤 변화가 무엇에서 왔는지 알 수 없으므로 원인을 볼 때는 한 곳씩만 바꾼다. 바꿀 값의 위치는 소스 주석에 그대로 적어 두었다.

화면 낭독기와 움직임 줄이기 — 메모리 접근성

슬롯 상태는 색만이 아니라 라벨과 채움 높이로도 구분된다 — 감쇠된 슬롯은 점선 윤곽이라는 모양 차이가 함께 있고, 슬롯이 밀릴 때마다 낭독기가 턴 목록 전체를 반복 읽지 않게 상태 줄의 aria-live 는 꺼 두고 승격·소거 같은 사건 문장만 role=status 로 안내한다. 일시정지는 진짜 button 이라 키보드로 조작되고 Space · R · 방향키 프리셋 전환도 실제로 동작한다.

@media (prefers-reduced-motion: reduce) {
  .ez * { animation: none !important; transition: none !important; }
  .ez__pause { transition: none !important; }
}

움직임을 줄이는 설정에서는 최종 슬롯 상태 한 장만 남긴다 — 감쇠·승격·압축이 끝난 뒤의 모습이 정지 화면에 그대로 있으므로 정보는 줄지 않는다. prefers-reduced-motion 은 Chrome 74 · Firefox 63 · Safari 10.1 부터 지원되어 호환 걱정 없이 붙인다. 이 데모의 톤은 크림 배경 위 파스텔 팔레트로 잡았고 세션 배지 두 색(짙은 남색 바탕 크림 글자 5.98:1 · 파스텔 라일락 바탕 잉크 글자 5.88:1)이 일반 텍스트 임계 4.5:1 을 넘겼다 — 가장 흐린 축 라벨 색도 5.25:1 이다.

메모리 데모를 받기 전에 자주 묻는 질문

n8n ai agent memory session id 는 무엇으로 정하면 되나요?

사용자가 캔버스를 벗어나지 않게 해 주는 안정 식별자 — 채팅 트리거라면 채팅방 ID, 웹 훅이라면 쿠키·사용자 ID 같이 같은 사람이면 같은 값을 주는 것으로 정합니다. 02 의 keyHash 가 보여 주듯 키 값이 곧 서랍 주소이므로, 세션마다 바뀌는 값(타임스탬프 등)을 쓰면 09 의 복원이 아예 성립하지 않습니다. 반대로 여러 사용자가 같은 Session ID 를 공유하면 대화가 섞이는 것이 01 의 경로 분기가 무너지는 모습입니다.

이 zip 의 코드를 n8n 워크플로에 그대로 붙여 넣으면 되나요?

아니요 — 이 zip 은 HTML·SCSS 데모와 react 판이지 n8n 워크플로 JSON 이 아닙니다. 실제 메모리 노드는 n8n 캔버스에서 AI Agent 노드에 Simple Memory · Window Buffer Memory · Postgres Chat Memory · MongoDB Chat Memory 같은 Memory 서브노드를 붙여 구성하고, 이 데모는 그 구성이 턴마다 무엇을 하는지 미리 보는 자료로 함께 두면 됩니다.

데모의 감쇠와 승격·압축은 실제 n8n 과 같은가요?

다릅니다 — 실제 n8n 의 Window Buffer Memory 는 설정한 컨텍스트 길이 그대로 최근 턴을 유지할 뿐 α=0.72 같은 자동 감쇠 곡선을 돌리지 않고, 요약 압축과 장기기억 저장은 연결된 챗 모델과 서브노드 구현이 결정합니다. 이 데모의 감쇠·자카드·레벤슈타인·압축비는 그 동작을 눈으로 볼 수 있게 만든 교육용 규칙 근사이며 값이 실제와 다를 수 있습니다 — 다만 예산을 넘으면 오래된 맥락부터 희생되고 세션 키가 유지·소거·복원의 단위가 된다는 방향은 실제 시스템에서도 같습니다.

에이전트 축의 앞 편은 n8n ai agent 도구 루프 9종이고, n8n ai agent memory 를 실제 워크플로로 굴리는 데이터 쪽은 n8n 워크플로우 예제 9종에서, 채팅 화면의 응답이 흘러 들어오는 모습은 AI 채팅 스트리밍 9종에서 이어진다.

압축 비밀번호를 입력하세요

비밀번호는 이 글 본문 안에 있습니다. 읽다 보면 나옵니다.