Budowa MemPalace: Bezpieczna lokalna pamięć dla AI z Cloudflare Zero Trust i Antigravity IDE

MemPalace

“Memory is identity.” (Pamięć to tożsamość.)
— mempalaceofficial.com

MemPalace zdobył niedawno ogromną popularność w sieci – częściowo za sprawą wsparcia ze strony gwiazd, takich jak Milla Jovovich, a częściowo przez dosyć kontrowersyjne wyniki benchmarków, które społeczność AI szybko zweryfikowała i obaliła. Jeśli jednak odrzucimy marketingowy szum i dramaty wokół syntetycznych testów wydajności, sama architektura leżąca u podstaw projektu oferuje coś naprawdę użytecznego: lokalną, trwałą bazę wektorową połączoną z Twoim IDE za pomocą Model Context Protocol (MCP).

Projekt ten stał się idealnym katalizatorem do promocji standardu Model Context Protocol (MCP) od Anthropic w połączeniu z wybranymi narzędziami AI.

MemPalace to rozwiązanie typu local-first, zapewniające pamięć dla agentów AI. Jest ono udostępniane za darmo społeczności na GitHubie na licencji MIT.

Głównym celem projektu jest – właśnie poprzez wykorzystanie pamięci – znaczne ograniczenie zużycia okna kontekstowego wybranych modeli AI i pomoc użytkownikom w utrzymaniu się w ramach ustalonych limitów zapytań (jakiekolwiek by one nie były).

Co wnosi do gry

Zwykle, gdy zaczynasz nowy czat z narzędziem AI, nie ma ono pojęcia, kim jesteś ani nad czym pracowałeś wczoraj. O ile nie ma włączonej własnej pamięci i personalizacji (które i tak są mocno ograniczone), każdy czat jest nową rozmową z zaledwie minimalnym tłem na Twój temat. MemPalace zapisuje całą historię konwersacji w sprytny sposób, dzięki czemu AI może przywołać konkretne decyzje lub szczegóły sprzed jakiegoś czasu, pozwalając uniknąć tzw. cyfrowej amnezji (Digital Amnesia).

Każdy czat z dowolnym narzędziem AI posiada tzw. okno kontekstowe (swój podręczny mózg). Może ono zapamiętać i przetwarzać (pracować nad) tylko ograniczoną ilość informacji. Gdy okno kontekstowe się przepełnia, AI musi usunąć z niego część danych. Zazwyczaj tracone są informacje lub instrukcje podane na samym początku, przez co w pewnym momencie tej samej rozmowy pojawiają się halucynacje i masz wrażenie, że AI zapomniało o czymś kluczowym.

Projekt od samego początku stawia na prywatność. Ponieważ może działać w trybie offline lub w bezpiecznym, odizolowanym środowisku, Twoje dane nigdy nie opuszczają wyznaczonego urządzenia. Nie ma tu żadnych opłat za chmurę ani obaw, że jakaś firma będzie trenować swoje modele na Twoich prywatnych plikach.

MemPalace wykorzystuje niezwykłą metodę organizacji danych. Różne projekty są przechowywane w dedykowanych „skrzydłach” (wings), tematy w „pokojach” (rooms), a konkretne szczegóły w „szufladach” (drawers). Dzięki temu znajdowanie właściwych informacji jest znacznie szybsze i dokładniejsze niż przeszukiwanie gigantycznej, chaotycznej listy plików czy przeglądanie tasiemcowych czatów, w których kontekst z początku rozmowy zaczyna po prostu znikać.

Dlaczego to rozwiązanie jest tak dobre

Większość systemów próbuje „podsumowywać” to, co powiedziałeś, przez co oryginalny sens często ulega zatraceniu. MemPalace zapisuje Twoje słowa dokładnie tak, jak zostały wypowiedziane, dbając o to, by nic nie zgubiło się w tłumaczeniu.

Nie musi wywoływać kosztownego modelu AI tylko po to, by zapisać lub odnaleźć wspomnienie – do wykonania najcięższej pracy wykorzystuje sprytne wyszukiwanie lokalne, które jest całkowicie darmowe.

Zostało zaprojektowane tak, aby przypominać prawdziwy Pałac Pamięci – technikę stosowaną już w starożytnej Grecji do zapamiętywania ogromnych ilości informacji poprzez wyobrażanie ich sobie w przestrzeni fizycznej.

Wszystko to brzmi bardzo inspirująco.

Podczas gdy obecnie internetowe czaty AI, takie jak Gemini, nie obsługują protokołu MCP, istnieje kilka narzędzi, które go wspierają. Jeśli edytujesz pliki na swoim komputerze – od programowania i tworzenia stron internetowych po zwykłą pracę nad tekstem w formacie Markdown – możesz natknąć się na aplikację o nazwie VS Code.

Dzięki protokołowi MCP w VS Code (lub w odpowiedniku tej aplikacji, będącym jej forkem) możesz podłączyć do niej najróżniejsze rozwiązania. Dodanie MemPalace za pośrednictwem protokołu MCP zapewni Twojemu narzędziu AI unikalną pamięć, co pozwoli Ci zaoszczędzić czas i, co ważniejsze, tokeny.

Każde narzędzie AI ma swoje limity. Im więcej płacisz, tym więcej możesz zrobić, a Twoje limity nie wyczerpują się tak szybko – jednak żadne z narzędzi nie pozwala na pracę non stop bez jakichkolwiek ograniczeń. Powtarzanie się i wprowadzanie informacji, które Ty pamiętasz, ale Twoje narzędzie już nie, prowadzi do niepotrzebnego marnowania dostępnych limitów.

Wyobraź sobie, że…

Każdy projekt, nad którym pracujesz, może stać się skrzydłem (wing). Skrzydła nie będą się ze sobą mieszać, chyba że zdecydujesz się użyć tuneli międzyszkrzydłowych (Cross-Wing Tunnels).

Gdy pracujesz nad projektem strony internetowej w VS Code, projekt ten może stać się Twoim Skrzydłem1 (Wing1). W ramach tego projektu tworzysz sprytny kod, który chcesz wykorzystać w kolejnym tworzonym projekcie, aby nie wymyślać koła na nowo – ten nowy projekt będzie Twoim Skrzydłem2 (Wing2).

Bez konieczności pamiętania, jak to zrobiłeś ani w których plikach zapisałeś te rzeczy, możesz przywołać wspomnienie z MemPalace i za pomocą tunelu międzyszkrzydłowego kontynuować pracę, dzieląc się tym, co zostało już wcześniej rozwiązane.

To jak w Google Gemini: kiedy zaczynasz nowy czat, możesz dodać Notatnik Gemini (Gemini Notebook), w którym gromadzisz wszystkie źródła mogące mieć znaczenie dla rozmowy. Twoja konwersacja rozpoczyna się od razu z pewnymi źródłami i pamięcią na samym początku.

To tak, jakbyś zaczynał pracę w jednym miejscu, gdzie uczysz się nowych rzeczy. Kiedy odchodzisz i przechodzisz do innej firmy, nie zaczynasz od zera – przywołujesz z pamięci to, czego nauczyłeś się w poprzednim miejscu, i wykorzystujesz tę wiedzę w nowym miejscu pracy. Na tym właśnie w swojej istocie polega idea MemPalace.

Jak przechowywane są informacje

MemPalace nie służy jedynie do „zapisywania tasiemcowego czatu” – dzieli Twoje informacje na małe, doskonale uporządkowane klocki LEGO.

Zamiast zmuszać AI do czytania 100-stronicowej historii rozmowy za każdym razem, gdy zadajesz pytanie, MemPalace:

• Wyciąga esencję – identyfikuje kluczowe fakty, osoby i decyzje.
• Kategoryzuje według „Pokojów” (Rooms) – segreguje te fakty do „szaf” i „szuflad” na podstawie tematu.
• Wyszukuje tylko to, co niezbędne – gdy zadajesz pytanie, wyciąga wyłącznie te konkretne „klocki”, które są potrzebne do odpowiedzi, zamiast wysypywać całe wiaderko.

Dzięki temu system jest szybki i wydajny, ponieważ AI nie jest przytłoczone informacyjnym „szumem” i widzi tylko istotne fakty. Co jednak najważniejsze, Twoje długie czaty nie pożerają drastycznie Twoich limitów, gdy odpowiadasz na proste pytanie, które równie dobrze można by sprawdzić w Google.

W przeciwieństwie do wielu narzędzi pamięci dla AI, które polegają na modelu tworzącym skompresowane podsumowanie czatu, MemPalace zapisuje Twoje dokładne słowa w ich oryginalnej formie. Twoje „klocki” to pierwotne transkrypcje, co oznacza, że żaden niuans nie zostaje utracony.

Podczas rozmowy system dzieli tekst na mniejsze, nachodzące na siebie fragmenty (chunk) – zazwyczaj o wielkości około 512 tokenów – dzięki czemu kontekst nie gubi się na granicach długich wiadomości.

Dane są porządkowane w strukturze wirtualnego budynku:

• Skrzydła (Wings): Katerogie najwyższego poziomu dla całych projektów lub osób.
• Pokoje (Rooms): Konkretne tematy w obrębie danego skrzydła – takie jak dyskusje techniczne, spotkania czy planowanie.
• Halle (Halls): Klasyfikacja typu pamięci – np. fakty, wydarzenia czy preferencje.
• Szuflady (Drawers): Ostateczne miejsce docelowe, w którym mieszczą się poszczególne fragmenty tekstu.

Każda szuflada jest przekształcana w wektor matematyczny i bezpiecznie przechowywana w lokalnej bazie danych (zwanej ChromaDB).

Gdy zadajesz pytanie, system matematycznie porównuje Twoje zapytanie z zapisanymi wektorami. Oblicza wskaźnik trafności, aby otworzyć tylko te „szuflady”, które są istotne, dostarczając AI precyzyjny kontekst bez konieczności wczytywania całej historii czatu.

W gruncie rzeczy rozwiązanie to łączy wysoce ustrukturyzowany system tagowania z wyszukiwaniem matematycznym – dając AI dokładnie taki kontekst, jakiego potrzebuje, przy jednoczesnym zachowaniu całkowicie lokalnego i wydajnego porządku.

Gemini AI Pro oraz Antigravity IDE

Jako mojego codziennego edytora kodu używam VS Code lub VS Codium. Ten drugi działa identycznie, ale jest rozwiązaniem open-source i ma całkowicie usunięte usługi Microsoftu oraz domyślne funkcje AI.

Gdy zacząłem testować Gemini w planie AI Pro, przeszedłem na Antigravity IDE – odpowiednik VS Codium, ale z głęboką integracją z AI oraz kodowaniem agentowym (agentic coding).

W ramach planu AI Pro otrzymuję dostęp do agentów AI opartych na modelach Gemini oraz Claude. Wszystko to przy znacznie wyższych limitach użycia.

Pomimo wyższych limitów w droższym planie, wciąż łatwo mogę wyczerpać przydzieloną pulę zapytań. Jest ona podzielona na limit 5-godzinny (odnawiany co 5 godzin) oraz całkowite zużycie rozliczane w limite tygodniowym (odnawianym co tydzień).

Problem polega na tym, że rozmowa z agentem potrafi bardzo szybko zużyć dostępny limit, nawet przy prostych zadaniach. Każda konwersacja i każdy wygenerowany wynik to zużyte tokeny. Możliwość ograniczenia niepotrzebnego zużycia tokenów przy powtarzających się zadaniach byłaby niezwykle cenna – i właśnie tutaj z pomocą przychodzi pamięć MemPalace.

Protokół MCP w połączeniu z MemPalace pomoże mi rozłożyć dostępny limit tokenów w czasie, zapobiegając inflacji tokenów w długich rozmowach.

Jak MemPalace ogranicza zużycie tokenów w Antigravity IDE

1. Zastępuje ogromne zrzuty kontekstu precyzyjnym wyszukiwaniem (RAG)

• Bez MemPalace: W miarę jak moja rozmowa się rozwija lub gdy proszę Antigravity o przeanalizowanie dużych baz kodu i dawnych decyzji, agent musi ciągle wysyłać ogromne fragmenty historii transkrypcji lub całe pliki z powrotem do okna promptu.

• Z MemPalace: MemPalace przeszukuje moją bazę kodu, przeszłe decyzje oraz historię czatu lokalnie. Wykorzystując wyszukiwanie semantyczne (semantic retrieval) oraz dzielenie tekstu na fragmenty (chunking), wstrzykuje do okna kontekstowego wyłącznie małe, trafne wycinki (często zaledwie ~100–300 tokenów) dokładnie wtedy, gdy są potrzebne.

2. Zapobiega pętlom ponownej analizy u agenta

• Bez trwałej pamięci agent w nowej sesji często na nowo analizuje te same wzorce architektoniczne, ponownie czyta pliki konfiguracyjne lub powtarza metodą prób i błędów kroki, które rozwiązał już wczoraj.

• Zapisując wyciągnięte wnioski w swojej lokalnej pamięci (w szufladach i wpisach w dzienniku), agent pomija nadmiarowe pętle rozumowania, oszczędzając tysiące tokenów na sesję. Pozwala mi to korzystać z potężnego, ale limitowanego planu Gemini AI Pro znacznie dłużej.

3. Zoptymalizowana integracja z Antigravity

• MemPalace zawiera natywne hooki cyklu życia (mempalace-wake oraz mempalace-save), zaprojektowane specjalnie z myślą o Google Antigravity.

• Wstrzykuje ono pamięć w tle jako ulotną (ephemeral) wiadomość pojedynczej tury. Oznacza to, że kontekst pamięci jest wczytywany dokładnie dla danego zadania i automatycznie odrzucany w kolejnych turach promptu, dzięki czemu nie rozdyma na stałe mojego okna kontekstowego.

Nic nie jest za darmo – Podatek Tokenowy (Token Tax)

Podczas gdy MemPalace oszczędza tokeny na długości kontekstu, sama integracja MCP wiąże się z niewielkim „podatkiem tokenowym”:

• Narzut schematu narzędzi (Tool Schema Overhead): Dodanie serwera MCP rejestruje definicje jego narzędzi (takich jak mempalace_search, mempalace_add_drawer itp.) w prompcie systemowym. Każda wysłana wiadomość zawiera kilkaset dodatkowych tokenów opisujących te dostępne narzędzia dla modelu LLM.

• Cykle wywoływania narzędzi (Tool Calling Cycles): Gdy Antigravity decyduje się odpytać MemPalace, wykonuje dodatkową turę generowania (Agent: „Przeszukam MemPalace” → Uruchomienie narzędzia MCP → Agent odbiera wynik → Agent odpowiada).

Krótko mówiąc: w przypadku prostych, jednorazowych zadań obecność MemPalace spowoduje nieznaczny wzrost zużycia tokenów. Jednak im dłuższa i bardziej złożona staje się rozmowa (30+ wiadomości), tym bardziej zauważalne staje się poleganie na pamięci i ogromna redukcja zużycia tokenów.

Jeśli pracujemy nad projektem przez dłuższy czas, będzie on stale obecny w pamięci. Każda kolejna interakcja nie będzie wymagała od agenta ponownego uczenia się o samym projekcie ani o rzeczach, które zostały już wdrożone.

Stosowany w prawidłowy sposób MemPalace znacząco wydłuży mój dostępny limit tokenów w czasie.

Dobra wiadomość dla obecnych użytkowników Antigravity IDE, którzy mają już zgromadzone wcześniejsze czaty: po zintegrowaniu MemPalace można zawsze wrócić do starych rozmów i za pomocą prostej komendy zrzucić („dump”) istotne informacje do pamięci przy użyciu specjalnej komendy. Więcej na ten temat w dalszej części artykułu.

Architektura rozwiązania (The Framework)

Aby rozpocząć pracę z MemPalace, zastosuję podejście podzielone na 4 kroki, wraz z jednym krokiem dodatkowym, służącym do przeniesienia dotychczasowych czatów do pamięci.

Celem jest zapewnienie mojemu asystentowi AI trwałej, własnoręcznie hostowanej pamięci długotrwałej („Pałacu”) we wszystkich moich projektach i repozytoriach, bez konieczności wysyłania prywatnych notatek do zewnętrznych serwisów pamięciowych.

1. Konfiguracja lokalna w Homelabie

Wdrożymy MemPalace w kontenerze Docker na lokalnym serwerze, wraz z trwałym magazynem wektorowym oraz modelami osadzającymi (embedding models). Skonfigurujemy całe środowisko i upewnimy się, że przynajmniej lokalne połączenie z pamięcią działa prawidłowo w sieci domowej.

2. Bezpieczny dostęp zdalny

W kolejnym kroku udostępnimy punkt końcowy (endpoint) za pośrednictwem tunelu Cloudflare Tunnel i zabezpieczymy go nagłówkami Cloudflare Access (Client ID oraz Secret).

Ponieważ mój serwer znajduje się za NAT-em, jeśli zechcę uzyskać do niego dostęp – a konkretnie do mojego MemPalace – z poziomu innej instancji programowania agentowego (Agentic Coding), muszę go najpierw wystawić na zewnątrz.

W tym celu wykorzystam punkt końcowy SSE przez protokół HTTPS za pośrednictwem tunelu Cloudflare Tunnel, rygorystycznie zabezpieczony za pomocą Cloudflare Access przy użyciu tokenów usługowych (Service Tokens: CF-Access-Client-Id oraz CF-Access-Client-Secret).

Mój domowy router z systemem OpenWrt posiada już aktywny tunel Cloudflare Tunnel, dzięki czemu użyję odizolowanego, zabezpieczonego i uwierzytelnionego połączenia z moim MemPalace, bez wystawiania całego serwera na bezpośrednie zagrożenia z internetu.

3. Integracja MCP z Agentem

Połączymy Antigravity IDE natywnie poprzez plik .agents/mcp_config.json lub konfigurację globalną.

Wprowadzając odpowiednie zmiany w konfiguracji, umożliwimy Agentowi dostęp do naszego MemPalace, a dzięki zdefiniowanym tunelom międzyszkrzydłowym (Cross-Wing Topic Tunnels) pozwolimy mu na przeszukiwanie różnych repozytoriów i uczenie się z nich. Czasami coś, co zbudowaliśmy już w innym miejscu, można po prostu wykorzystać ponownie. Posiadając tę wiedzę, sprawimy, że zużycie tokenów potrzebnych do komunikacji stanie się znacznie bardziej opłacalne.

4. Protokoły instrukcji (Instruction Protocols)

Napiszemy instrukcje systemowe, które obsłużą automatyczne wykrywanie skrzydeł (Wings) oraz taksonomię pokojów (Rooms).

5. Komenda „Zrzutu” (The “Dump” Command)

Za pomocą prostej komendy zrzucimy część naszych dawnych rozmów do pamięci, dzięki czemu kontynuując pracę nad nimi, skutecznie zaoszczędzimy tokeny.

Konfiguracja (The Setup)

W niniejszym przewodniku zakładam, że posiadasz już działający serwer domowy z uruchomionym środowiskiem Docker oraz interfejsem do zarządzania, takim jak Portainer. Z tego względu nie będę opisywać wstępnej konfiguracji serwera, podstawowej instalacji Dockera ani konfigurowania tunelu Cloudflare Tunnel (co opisałem już we wcześniejszym artykule na mojej stronie). Jeśli potrzebujesz pomocy z którymkolwiek z tych wymagań wstępnych, śmiało poproś swoje ulubione narzędzie AI o przeprowadzenie Cię przez ten proces.

Wdrożenie „Mózgu” MemPalace w środowisku Docker

Zanim będziemy mogli połączyć nasze IDE z systemem pamięci AI, musimy zbudować ten „mózg” i zapewnić mu odpowiednie miejsce do działania. Hostując MemPalace lokalnie na własnym sprzęcie (w moim przypadku używam ASUS Chromebox 3 z zainstalowanym systemem Ubuntu Server), mam pewność, że moje prywatne notatki, fragmenty kodu oraz sekrety wdrożeniowe nigdy nie trafią na serwery firm trzecich.

Konfiguracja Docker Compose

Aby uruchomić MemPalace, wdrożymy go za pomocą stosu docker-compose.yml. W panelu Portainer utwórz nowy stos (stack), nazwij go mempalace i wklej następującą konfigurację:

services:
  mempalace-server:
    image: ghcr.io/mempalace/mempalace:latest
    container_name: mempalace-server
    restart: unless-stopped
    ports:
      - "8888:8888" # Exposing the port for our Cloudflare Tunnel
    # Override the default stdio command to run the SSE HTTP server
    command: ["serve", "--host", "0.0.0.0", "--port", "8888"] 
    volumes:
      # Maps your physical server folder to the container's internal data directory
      - ./mempalace/data:/data
    environment:
      # The embedding model used to "vectorize" your text
      - MODEL_NAME=all-MiniLM-L6-v2
      - LOG_LEVEL=INFO

Omówienie konfiguracji

Przyjrzyjmy się, dlaczego skonfigurowaliśmy to w ten sposób:

• Oficjalny obraz: Używamy ghcr.io/mempalace/mempalace:latest. Zawiera on wszystko, co niezbędne do uruchomienia serwera Model Context Protocol (MCP), bez konieczności instalowania lokalnego środowiska Pythona na naszym hoście.

• Montowanie wolumenu (/data): Obraz Dockera MemPalace domyślnie przechowuje bazę danych pałacu, pliki konfiguracyjne oraz zbuforowany model osadzający w katalogu /data. Mapując go na /server-config/mempalace/data na moim hoście, mam pewność, że pamięć mojego AI nie zostanie wyczyszczona w przypadku ponownego uruchomienia lub aktualizacji kontenera.

• MODEL_NAME: Używam modelu all-MiniLM-L6-v2. W świecie AI jest to model typu „Sentence Transformer”. Jego jedynym zadaniem jest przekształcanie notatek tekstowych na listę liczb (wektorów), aby baza danych mogła później wykonywać wyszukiwanie semantyczne. Jest niezwykle wydajny – przetwarza fakty w milisekundach na zwykłym procesorze (CPU), nie obciążając przy tym sprzętu.

Wdrożenie i weryfikacja

Zanim wdrożymy nasz kontener Docker, utwórzmy foldery, w których będą przechowywane dane, i nadajmy im odpowiednie uprawnienia:

1. Utwórz katalog na hoście:

sudo mkdir -p /home/darek/server-config/mempalace/data

2. Przyznaj uprawnienia właściciela dla UID 1000, aby kontener mógł w nim zapisywać dane:

sudo chown -R 1000:1000 /home/darek/server-config/mempalace/data

Oczywiście musisz odpowiednio dostosować ścieżkę do swojego katalogu.

Gdy uruchomimy stos (sudo docker compose up -d), dajmy mu chwilę na pobranie obrazu i start.

Aby zweryfikować, czy wszystko działa prawidłowo:

1. Otwórz logi kontenera w panelu Portainer.
2. Powinniśmy zobaczyć pasek postępu wskazujący, że plik onnx.tar.gz (mózg MiniLM) został pomyślnie pobrany.
3. Na koniec powinniśmy zobaczyć wpis w logach potwierdzający, że serwer nasłuchuje na porcie 8888.

Jeśli na którymkolwiek etapie zajdzie potrzeba aktualizacji pliku docker-compose.yml, pamiętaj, aby najpierw zatrzymać i usunąć kontener:

sudo docker rm -f mempalace-server

Jeśli wszystko zrobiliśmy poprawnie, w logach powinniśmy zobaczyć coś takiego:

Starting MemPalace remote MCP server
  palace   : /data/.mempalace/palace
  backend  : default
  bind     : 0.0.0.0:8888  (network-exposed)
  tls      : off (plaintext — terminate TLS at a proxy)
  read-only: no
  A new bearer token was generated and stored 0600 at:
    /data/.mempalace/server/ea14d52878fb2dc1c663911a/token
  Store it securely — clients need it to connect:
    xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
Connect a client:
  claude mcp add --transport http mempalace http://YOUR_SERVER_HOST:8888/mcp --header "Authorization: Bearer WsG63kI_joz1eozHomwzrnxeTmej3qlg1ER6zkrnfjU"
  curl http://YOUR_SERVER_HOST:8888/healthz   # liveness (no auth)
MemPalace MCP HTTP server starting...
MemPalace MCP HTTP server bound to non-loopback host 0.0.0.0; /mcp requires the configured bearer token.
MemPalace MCP HTTP server listening on http://0.0.0.0:8888/mcp

Na tym etapie zapisz wygenerowany bearer token i zachowaj go na później.

MemPalace rygorystycznie stosuje strategię „leniwego ładowania” (lazy loading) dla swoich modeli. Pobieranie modelu uruchamia się wyłącznie przy pierwszym wykonaniu komendy.

Wywołajmy to pobieranie teraz, aby nasze IDE nie napotkało później błędu przekroczenia limitu czasu (timeout). W tym celu wystarczy wykonać kilka poleceń.

Inicjalizacja Pałacu

Najpierw wydajmy polecenie MemPalace, aby utworzył swoją wewnętrzną strukturę bazy danych wewnątrz zamapowanego folderu /data.

sudo docker exec -it mempalace-server mempalace init /data

Ta komenda tworzy niezbędne pliki i upewnia się, że katalog konfiguracyjny istnieje.

Gdy pojawi się pytanie Mine this directory now? [Y/n], zatwierdź wpisując Y.

Wywołanie pobierania modelu

Teraz, gdy baza danych już istnieje, możesz uruchomić testowe wyszukiwanie. Ponieważ system ma już w czym szukać, napotka wymóg użycia modelu osadzającego (embedding) i natychmiast rozpocznie pobieranie modelu all-MiniLM-L6-v2 o rozmiarze 80 MB:

sudo docker exec -it mempalace-server mempalace search "wake up brain"

Idealnie poprawny wynik będzie wyglądał następująco:

/data/.cache/chroma/onnx_models/all-MiniLM-L6-v2/onnx.tar.gz: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 79.3M/79.3M [00:03<00:00, 21.2MiB/s]
No results found for: "wake up brain"

Na tym etapie nasza lokalna baza danych pamięci dla AI jest oficjalnie gotowa, a odpowiedni model został pobrany.

Punkt kontrolny – Weryfikacja połączenia lokalnego

Zanim przejdziemy dalej, sprawdźmy, czy nasz MemPalace działa lokalnie.

5-sekundowy test ping (Terminal)

Otwórz terminal na swoim lokalnym komputerze i wykonaj szybki test stanu (health check) na lokalnym adresie IP swojego serwera:

curl http://192.168.1.239:8888/healthz

Jeśli kontener działa, a port 8888 jest otwarty, natychmiast zwróci on proste OK lub status w formacie JSON.

W logach panelu Portainer również zobaczysz tę komunikację:

HTTP 192.168.1.242 - "GET /healthz HTTP/1.1" 200 -

Test lokalnego IDE (Antigravity)

Teraz połączmy nasze IDE lokalnie. Pozwoli to potwierdzić, że protokół MCP oraz token Bearer działają prawidłowo.

W Antigravity IDE przejdź do panelu czatu, wybierz MCP Servers z menu trzech kropek u góry i – ignorując załadowaną listę – kliknij Manage MCP Servers. Jeśli nie masz tam nic skonfigurowanego („No MCP servers installed”), kliknij po prostu View raw config i zastąp zawartość:

{
"mcpServers": {}
}

Na:

{
	"mcpServers": {
		"mempalace-local": {
		"serverUrl": "http://192.168.1.239:8888/mcp",
			"headers": {
			"Authorization": "Bearer xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
			}
		}
	}
}

Upewnij się, że używasz rzeczywistego adresu IP swojego serwera oraz tokena, który zapisałeś z logów Dockera.

Test pamięci „Hello World”

Zamknij całkowicie edytor Antigravity IDE i uruchom go ponownie.

W logach panelu Portainer zobaczysz, jak Antigravity IDE komunikuje się z naszym lokalnym MemPalace za pomocą protokołu MCP:

HTTP 192.168.1.242 - "POST /mcp HTTP/1.1" 202 -
HTTP 192.168.1.242 - "POST /mcp HTTP/1.1" 200 -

Otwórz sekcję czatu w Antigravity IDE i wpisz poniższy prompt:

Korzystając z narzędzi `#mempalace-local`, zapisz następującą notatkę: „Local network MCP connection is fully operational” w pokoju „infrastructure” w skrzydle „test_wing”.

Po uzyskaniu prawidłowej odpowiedzi zobaczysz:

Użyte narzędzie MCP: mempalace-local/mempalace_add_drawer

Notatka została pomyślnie zapisana w Mempalace:

* **Treść:** `'Local network MCP connection is fully operational'`
* **Skrzydło (Wing):** `test_wing`
* **Pokój (Room):** `infrastructure`
* **ID Szuflady (Drawer ID):** `drawer_test_wing_infrastructure_39715aca9c5c52e3384f6bb7`

W logach kontenera Docker w panelu Portainer zobaczysz:

Embedding function initialized (model=minilm device=cpu providers=['CPUExecutionProvider'])
Filed drawer: drawer_test_wing_infrastructure_39715aca9c5c52e3384f6bb7 → test_wing/infrastructure
HTTP 192.168.1.242 - "POST /mcp HTTP/1.1" 200 -

Teraz jesteśmy gotowi na kolejny krok.

Jeśli wystarcza Ci wyłącznie lokalny dostęp do Twojego MemPalace, możesz pominąć niektóre z poniższych punktów i przejść bezpośrednio do sekcji Protokoły instrukcji (Instruction Protocols) oraz Komenda „Zrzutu” (The “Dump” Command) dla swoich dotychczasowych czatów.

Bezpieczny dostęp zdalny z Cloudflare Zero Trust

Gdy nasz MemPalace działa już lokalnie, nadszedł czas, aby udostępnić go z poziomu internetu… w bezpieczny sposób.

Firma Cloudflare wprowadziła funkcje do zarządzania środowiskami korporacyjnymi z wieloma agentami AI i serwerami MCP poprzez portale serwerów MCP w ramach kontroli dostępu Zero Trust > Access.

Jednak w przypadku prywatnego środowiska domowego (homelab) z pojedynczą instancją MemPalace, zastosowanie dedykowanego podejścia Zero Trust Application + Service Token jest w rzeczywistości najbardziej niezawodną i uniwersalnie kompatybilną metodą. Daje ono bezpośrednią, pełną kontrolę nad nagłówkami w naszym IDE. W tym artykule najlepiej przedstawić tę podstawową metodę, ponieważ dokładnie wyjaśnia ona, jak w praktyce działa uwierzytelnianie maszynowe (Machine-to-Machine – M2M).

Założenie: Posiadasz już uruchomiony i prawidłowo działający usługa cloudflared w swojej sieci (widoczną i aktywną w sekcji Networks > Tunnels & Mesh). Twoja domena jest również zarządzana przez Cloudflare.

Tworzenie tunelu (The Pipe)

1. Przejdź do Networks > Tunnels & Mesh i kliknij nazwę swojego tunelu.
2. Wybierz Published application routes z górnego menu.

3. Kliknij niebieski przycisk + Add a published application route.
4. Skonfiguruj przekierowanie – tak jak w poniższym przykładzie:

• Subdomain: mempalace
• Domain: (wybierz preferowaną domenę z listy swoich domen)
• Service
  • Type: HTTP
  • URL: (adres naszego lokalnego serwera, np.: 192.168.0.1:8888)

Nasz serwer w sieci lokalnej jest dostępny przez nieszyfrowany protokół HTTP, jednak nasz tunel po drodze doda do niego szyfrowanie HTTPS.

Kliknij Save. Cloudflare automatycznie utworzy dla Ciebie odpowiedni rekord DNS.

W tym momencie nasz MemPalace jest widoczny w internecie, ale pozostaje całkowicie niezabezpieczony. Każdy, kto odgadnie adres mempalace.twojadomena.com, może uzyskać do niego dostęp. Nadszedł czas, aby go zabezpieczyć.

Tworzenie tokenu usługowego (Service Token – Klucz Maszynowy)

Ponieważ Twoje IDE (takie jak Antigravity) działa w tle, nie może otworzyć przeglądarki internetowej, aby kliknąć przycisk „Zaloguj się”. Wymaga ono dostępu programistycznego. Osiągamy to za pomocą tokenów usługowych (Service Tokens). Musimy utworzyć taki token zanim zbudujemy naszą tarczę ochronną.

1. Przejdź do Access controls > Service credentials.
2. Kliknij przycisk + Create service token:

• Name: MemPalace
• Service Token Duration: Non-expiring

3. Kliknij przycisk Generate token.

Wyświetlą się szczegóły tokenu usługowego (Service token details). Musisz skopiować nagłówek i tajny klucz klienta (Header and client secret) i zapisać je w bezpiecznym miejscu, ponieważ zostaną wyświetlone tylko jeden raz.

Skopiuj również swój CF-Access-Client-Id, ponieważ będzie Ci potrzebny w dalszej części:

CF-Access-Client-Id: your-client-id-here.access
CF-Access-Client-Secret: your-client-secret-here

4. Potwierdź, klikając przycisk Done.

Aplikacja Zero Trust (Tarcza Ochronna)

Musimy postawić „ochroniarza” przed naszą poddomeną.

1. W panelu Zero Trust przejdź do Access controls > Applications.
2. Kliknij + Create new application i wybierz Self-hosted and private.

• Z dostępnych opcji wybierz Public DNS i kliknij Continue with self-hosted and private.

3. Wypełnijmy konfigurację:

• Destinations
  • Subdomain: mempalace
  • Domain: (tak jak wybrano wcześniej)
• Access policies – kliknij przycisk Create new policy.
  • Policy rules
    • Selector is: Service token
    • Poniżej wybierz utworzony wcześniej token MemPalace.
• Policy details
  • Policy Name: MemPalace Service Token Auth
  • Action: Service Auth
  • Policy session duration: Same as application session duration

4. Potwierdź, klikając przycisk Save policy.
5. W sekcji Preview upewnij się, że wszystko wygląda tak jak poniżej:

• Sources: Services
• Policies: MemPalace Service Token Auth
• Destination: mempalace.example.com (Twoja wcześniej wybrana domena)

6. W sekcji Details wypełnij:

• Name: MemPalace Server
• Session Duration: 24 hours

7. Potwierdź, klikając przycisk Save.

Wymuszenie walidacji tokena JSON Web Token (JWT) w Cloudflare Access

1. Wróć do Networks > Tunnels & Mesh i kliknij swój tunel.
2. Przejdź do Published application routes, kliknij utworzoną wcześniej trasę, a następnie wybierz przycisk Edit.
3. Przewiń na sam dół i otwórz sekcję o nazwie Origin request and connection settings.
4. Otwórz sekcję Access i włącz opcję Enforce Access JSON Web Token (JWT) validation.
5. Z rozwijanej listy wybierz swój MemPalace Server i kliknij Save.

Ten dodatek wprowadza powiązaną bezpośrednio z naszą aplikacją Access dodatkową warstwę bezpieczeństwa, co gwarantuje, że nikt nie minie naszego „ochroniarza” poprzez odkrycie wewnętrznego przekierowania w tunelu.

Punkt kontrolny – Weryfikacja połączenia zdalnego

Zanim podłączymy to wszystko do naszego IDE, upewnijmy się, że nasz „ochroniarz” w Cloudflare wykonuje swoją pracę, a nasz token usługowy (Service Token) działa jak przepustka VIP, która przepuszcza nas dalej.

Test „ochroniarza” (Test niepowodzenia)

Najpierw spróbuj uzyskać dostęp do swojego zdalnego serwera bez podawania żadnych poświadczeń. Uruchom poniższe polecenie w terminalu:

curl -I https://mempalace.yourdomain.com/healthz

(Uwaga: flaga -I nakazuje programowi curl pobranie wyłącznie nagłówków HTTP).

Oczekiwany rezultat: Powinieneś zobaczyć przekierowanie HTTP/2 302 lub błąd HTTP/2 403 Forbidden wskazujący na stronę logowania Cloudflare Access. Dowodzi to, że Twój serwer nie jest już wystawiony na publiczny internet!

Test przepustki VIP (Test sukcesu)

Teraz przedstawmy nagłówki naszego tokenu usługowego (Service Token), aby ominąć ochroniarza. Będziesz potrzebować identyfikatora Client ID (z końcówką .access) oraz Client Secret, które zapisałeś w Fazie 2.

Uruchom poniższe polecenie, zastępując symbole zastępcze swoją rzeczywistą domeną i poświadczeniami Cloudflare:

curl -i https://mempalace.yourdomain.com/healthz \
  -H "CF-Access-Client-Id: your-client-id-here.access" \
  -H "CF-Access-Client-Secret: your-client-secret-here"

Oczekiwany rezultat: Jeśli wszystko zostało skonfigurowane poprawnie, Cloudflare odczyta te nagłówki, zweryfikuje token JWT, przepuści żądanie przez tunel, a MemPalace odpowie komunikatem: HTTP/2 200 OK

Jeśli otrzymasz odpowiedź 200 OK, nasza architektura zdalna działa bez zarzutu! Pomyślnie i bezpiecznie nawiązałeś połączenie tunelowe ze swoją siecią domową.

W logach Dockera zobaczysz również odpowiedź pochodzącą bezpośrednio z Twojego routera (ponieważ żądanie przechodzi przez internet).

Integracja z IDE i MCP (Podłączanie Mózgu)

Na tym etapie zbudowaliśmy dwuwarstwowy model bezpieczeństwa dla komunikacji między naszym MemPalace a IDE:

• Nagłówki Cloudflare (CF-Access-Client-*): Identyfikator pozwalający przejść obok „ochroniarza” przy drzwiach wejściowych do Twojej sieci.
• Token Bearer (Authorization): Klucz do otwarcia właściwego sejfu (MemPalace), gdy jesteś już w środku.

Sam MemPalace nie ma pojęcia o istnieniu Cloudflare. Nawet jeśli Cloudflare przepuści ruch, MemPalace i tak odrzuci go ze statusem 401 Unauthorized, jeśli do żądania nie zostanie dołączony token Bearer.

Skoro nasz serwer MemPalace jest już bezpiecznie udostępniony w internecie, musimy nauczyć nasze IDE, jak ma się z nim komunikować. Przypominam tylko, że w tym poradniku używamy Antigravity IDE, które posiada natywne, pełne wsparcie dla protokołu Model Context Protocol (MCP). Standardowy edytor VS Code z integracją z GitHub Copilot również potrafi wykorzystywać MCP oraz MemPalace – wypróbowałem to rozwiązanie, jednak wymaga ono płatnego planu, aby działać efektywnie. W darmowym planie Copilot Free szybko wyczerpiesz swój limit tokenów, zanim MemPalace zostanie aktywnie wykorzystany.

Koncepcja dwuwarstwowych zabezpieczeń

Aby pomyślnie się połączyć, musimy jednocześnie przejść przez dwie różne warstwy zabezpieczeń:

1. Tarcza obwodowa (Perimeter Shield): Cloudflare potrzebuje naszego Client ID oraz Client Secret, aby wpuścić ruch do naszej sieci domowej.
2. Blokada aplikacji (Application Lock): MemPalace wymaga tokena Bearer Token (wygenerowanego na początku konfiguracji MemPalace w Dockerze), aby przyznać dostęp do bazy danych.

Antigravity IDE pozwala nam przekazać wszystkie te „klucze” natywnie, za pomocą standardowych nagłówków HTTP.

Konfiguracja Antigravity IDE

Po raz kolejny w Antigravity IDE przejdź do panelu czatu, wybierz MCP Servers z menu trzech kropek u góry i – ignorując załadowaną listę – kliknij Manage MCP Servers. Jeśli nie masz tam nic skonfigurowanego („No MCP servers installed”), kliknij po prostu View raw config i wklej poniższe:

{
  "mcpServers": {
    "mempalace-remote": {
      "serverUrl": "https://mempalace.yourdomain.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_MEMPALACE_BEARER_TOKEN",
        "CF-Access-Client-Id": "YOUR_CLOUDFLARE_CLIENT_ID.access",
        "CF-Access-Client-Secret": "YOUR_CLOUDFLARE_CLIENT_SECRET"
      }
    }
  }
}

Zastąp swoją domenę w serverUrl oraz uzupełnij wartości tokenów Bearer i CF-Access. Zapisz plik i całkowicie zamknij Antigravity IDE.

Otwórz ponownie Antigravity i spójrz na panel czatu. Jeśli nie widzisz żadnych komunikatów o błędach MCP, najprawdopodobniej wszystko poszło dobrze. Aby to zweryfikować, sprawdź logi Dockera podczas uruchamiania Antigravity IDE. Zobaczysz w nich coś takiego:

HTTP 192.168.1.1 - "POST /mcp HTTP/1.1" 200 -
HTTP 192.168.1.1 - code 404, message Not Found
HTTP 192.168.1.1 - "GET /mcp HTTP/1.1" 404 -
HTTP 192.168.1.1 - "POST /mcp HTTP/1.1" 202 -
HTTP 192.168.1.1 - "POST /mcp HTTP/1.1" 200 -
HTTP 192.168.1.1 - code 501, message Unsupported method ('DELETE')
HTTP 192.168.1.1 - "DELETE /mcp HTTP/1.1" 501 -
HTTP 192.168.1.1 - "POST /mcp HTTP/1.1" 200 -
HTTP 192.168.1.1 - code 404, message Not Found
HTTP 192.168.1.1 - "GET /mcp HTTP/1.1" 404 -
HTTP 192.168.1.1 - "POST /mcp HTTP/1.1" 200 -
HTTP 192.168.1.1 - "POST /mcp HTTP/1.1" 202 -
HTTP 192.168.1.1 - code 404, message Not Found
HTTP 192.168.1.1 - "GET /mcp HTTP/1.1" 404 -
HTTP 192.168.1.1 - "POST /mcp HTTP/1.1" 202 -
HTTP 192.168.1.1 - "POST /mcp HTTP/1.1" 200 -
HTTP 192.168.1.1 - "POST /mcp HTTP/1.1" 200 -
HTTP 192.168.1.1 - "POST /mcp HTTP/1.1" 202 -

Potwierdza to komunikację z MemPalace poprzez infrastrukturę Cloudflare. Adres IP 192.168.1.1 to lokalny adres IP Twojego routera, co pokazuje, że żądanie pochodziło z internetu, a samo połączenie z Twoją instancją MemPalace zostało zainicjowane bezpośrednio przez router.

Protokoły instrukcji i taksonomia (Organizowanie Mózgu)

Skoro nasze IDE jest już bezpiecznie połączone z bazą danych MemPalace, musimy nauczyć AI, jak z niej korzystać. Jeśli nie ustalimy zasad podstawowych, AI będzie po prostu wrzucać wszystko do jednego wielkiego, nieuporządkowanego stosu.

Aby zapobiec chaosowi, MemPalace wykorzystuje specyficzną, 3-poziomową strukturę organizacyjną. Musimy wyjaśnić tę strukturę naszemu agentowi AI i dać mu reguły określające, jak ma się po niej dynamicznie poruszać.

Podstawowa hierarchia taksonomii

Pomyśl o MemPalace dokładnie tak, jak sugeruje nazwa – jak o fizycznym budynku. Organizujemy wiedzę na trzech poziomach:

• Skrzydła / Wings (Projekty / Repozytoria): Skrzydło reprezentuje odizolowaną przestrzeń roboczą projektu (np. my-website, home-server-config). Trzymanie projektów w osobnych Skrzydłach gwarantuje, że AI nie pomyli kroków wdrożeniowych dla Twojego bloga z regułami routingu dla sieci domowej.
• Pokoje / Rooms (Tematy / Kategorie): Pokoje reprezentują standardowe obszary tematyczne wewnątrz Skrzydła. Typowe pokoje to np. infrastructure, deployment, debugging czy architecture.
• Szuflady / Drawers (Pojedyncze notatki): Szuflady to właściwe, atomowe cząstki wiedzy zapisane w konkretnym Pokoju.

Dynamiczne automatyczne wykrywanie Skrzydeł

Jeśli pracujesz nad dziesiątkami projektów, nie chcesz za każdym razem po otwarciu czatu ręcznie mówić AI, w którym Skrzydle (Wing) się znajdujesz. Zamiast tego stosujemy inteligentny system wykrywania:

• Główna metoda: W głównym folderze (root) dowolnego projektu utwórz plik o nazwie mempalace_wing.txt zawierający nazwę projektu. AI odczyta ten plik, aby zidentyfikować swoje bieżące Skrzydło.

• Mechanizm awaryjny (Failsafe): Jeśli zapomnisz utworzyć ten plik, AI zadziała inteligentnie: automatycznie sprawdzi nazwę folderu aktualnie otwartego w Twoim IDE i użyje jej jako nazwy Skrzydła. Gwarantuje to, że Twoje wspomnienia są zawsze porządnie katalogowane.

Kategoryzacja Pokoi przez AI i Tunele Międzyskrzydłowe

Nie powinieneś musieć zapamiętywać nazw swoich Pokoi ani mówić AI, gdzie co umieścić. Ludzie zapominają; AI – nie. Poinstruujemy AI, aby działała jak zautomatyzowany bibliotekarz. Na podstawie kontekstu Twojej rozmowy AI automatycznie określi, do którego standardowego „Pokoju” należy Twoja notatka.

Dlaczego zależy nam na standardowych pokojach? Ze względu na Tunele tematyczne między Skrzydłami (Cross-Wing Topic Tunnels).

Jeśli rozwiążesz problem z CSS w projekcie my-website, a później poprosisz AI o pomoc z CSS podczas pracy nad friend-website, AI może przeszukać pokój infrastructure globalnie (pozostawiając parametr Wing pusty). Działa to jak tunel, pozwalający AI na wyciąganie Twoich wcześniejszych rozwiązań z całkowicie innych projektów.

Reguły i protokoły agenta (Instrukcje)

Zanim przejdziemy dalej, przeanalizujmy konfigurację Antigravity IDE:

• Reguły globalne / Global Rules (~/.gemini/GEMINI.md): To globalny „mózg” agenta. Cokolwiek tu napiszesz, będzie miało zastosowanie do każdego bez wyjątku projektu, który kiedykolwiek otworzysz. Jeśli chcesz, aby MemPalace był Twoim uniwersalnym systemem pamięci we wszystkich repozytoriach, to jest właściwe miejsce.
• Reguły przestrzeni roboczej / Workspace Rules (katalog .agents/rules/): To nowoczesny zamiennik dla .geminirules. Reguły te odnoszą się wyłącznie do konkretnego repozytorium, które masz aktualnie otwarte.
• Umiejętności / Skills (~/.gemini/config/skills/): Skills to wyspecjalizowane skrypty lub szablony ładowane przez AI na żądanie, tylko po wywołaniu. Ponieważ nasze instrukcje dla MemPalace określają zachowanie oraz taksonomię (jak kategoryzować informacje i kiedy przeszukiwać bazę), powinny się znaleźć w Regule (Rule), a nie w Umiejętności (Skill).

W przypadku MemPalace, skoro budujemy Tunele między Skrzydłami (Cross-Wing Tunnels) obejmujące wiele projektów, najlepszym miejscem na umieszczenie tych instrukcji są Reguły globalne (Global Rules).

Aby to wszystko działało automatycznie, musimy przekazać Antigravity IDE dokładne wytyczne. Ponieważ chcemy, aby MemPalace działał jako nasz uniwersalny mózg we wszystkich naszych projektach, dodamy te instrukcje jako Regułę globalną (Global Rule).

Reguła globalna działa jak stała podświadomość AI – będzie automatycznie analizować Twoje rozmowy oraz zapisywać lub przeszukiwać MemPalace w tle, bez konieczności wydawania poleceń z Twojej strony.

Ponieważ Antigravity stosuje Reguły globalne we wszystkich otwieranych projektach, musimy po prostu edytować główny plik konfiguracyjny na Twoim komputerze.

1. W Antigravity IDE naciśnij Cmd+P (Mac) lub Ctrl+P (Windows), aby otworzyć wyszukiwarkę plików.
2. Wpisz ~/.gemini/GEMINI.md i naciśnij Enter, aby otworzyć plik reguł globalnych. (Jeśli plik nie istnieje, po prostu otwórz terminal, uruchom polecenie touch ~/.gemini/GEMINI.md, a następnie otwórz go w IDE).
3. Dodaj do pliku następujący nagłówek YAML frontmatter oraz reguły:

# MemPalace Integration Rules

Jesteś połączony z systemem pamięci długoterminowej o nazwie MemPalace. Musisz go używać do automatycznego przywoływania wcześniejszych decyzji oraz zapisywania nowego, istotnego kontekstu.

## Taksonomia Skrzydeł (Wings) i Pokoi (Rooms)
- **Automatyczne wykrywanie Skrzydła:** Zawsze przed zapisaniem lub przeszukaniem określ swoje bieżące „Skrzydło” (Wing). Szukaj pliku `mempalace_wing.txt` w aktualnie aktywnym folderze. Jego zawartość reprezentuje nazwę Skrzydła.
- **Mechanizm awaryjny (Failsafe):** Jeśli plik `mempalace_wing.txt` nie zostanie znaleziony, NIE pozostawiaj pola Wing pustego. Użyj dokładnej nazwy bieżącego głównego folderu przestrzeni roboczej (lub aktywnego podfolderu) jako nazwy Skrzydła.
- **Obszary robocze wielorepozytorium (Multi-Repo):** Jeśli pracujesz w folderze nadrzędnym zawierającym wiele projektów (np. w katalogu GitHub), użyj aktywnego kontekstu czatu użytkownika, aby określić, w którym konkretnie podfolderze pracujemy, i zastosuj reguły wykrywania Skrzydła / mechanizmu awaryjnego do tego konkretnego podfolderu.
- **Automatyczna kategoryzacja Pokoi:** NIE polegaj na użytkowniku w kwestii podania nazwy Pokoju (Room). Działaj jako zautomatyzowany bibliotekarz. Na podstawie kontekstu czatu automatycznie zaklasyfikuj wspomnienie do jednego ze standardowych, zdefiniowanych wcześniej pokoi: `infrastructure`, `deployment`, `architecture`, `debugging`, `database` lub `general`.

## Autonomiczne protokoły operacyjne (Brak konieczności monitowania przez użytkownika)
1. **Przeszukaj zanim zadziałasz:** Przed podjęciem decyzji architektonicznych, napisaniem skryptów wdrożeniowych lub odpowiedzią na złożone pytania, automatycznie użyj narzędzia wyszukiwania MemPalace, aby sprawdzić istniejące wzorce w bieżącym Skrzydle i Pokoju.
2. **Tunele międzyskrzydłowe (Cross-Wing Tunnels):** Jeśli nie możesz znaleźć odpowiedzi w Skrzydle bieżącego projektu, wykonaj wyszukiwanie globalne, pozostawiając parametr `wing` PUSTY. Tworzy to tunel tematyczny między Skrzydłami, pozwalając na korzystanie ze znormalizowanych Pokoi (takich jak `infrastructure`) z moich innych projektów.
3. **Proaktywne zapisywanie rezultatów:** Nie czekaj, aż użytkownik powie „zapisz to”. Gdy decyzja architektoniczna zostanie sfinalizowana, złożony błąd rozwiązany lub ustalony nowy wzorzec, automatycznie podsumuj decyzję techniczną i zapisz ją w odpowiednim Skrzydle i ustalonym Pokoju.

Jeśli masz już skonfigurowane reguły globalne dla innych zadań, nie usuwaj ich! Ponieważ Antigravity traktuje ten cały plik jako swój globalny prompt systemowy, możesz po prostu przewinąć na sam dół istniejącego tekstu i wkleić reguły MemPalace bezpośrednio pod nim.

I to wszystko. Gotowe.

Antigravity IDE załaduje te wytyczne do swojego promptu systemowego dla każdego projektu, który kiedykolwiek otworzysz. Nie musisz wpisywać żadnych poleceń, określać pokojów ani mówić wprost „zapisz to w MemPalace”. AI po prostu zadziała w tle jako Twój cichy bibliotekarz.

Jednak…

Nie każdy lubi mieć stale aktywne Reguły Globalne; niektórzy wolą korzystać z MemPalace tylko wtedy, gdy sami o tym zdecydują.

Ręczny tryb pracy (Opt-In Workflow)

Jeśli myśl o tym, że AI po cichu zapisuje Twój kod w tle, wydaje Ci się zbyt intruzywna, możesz zamiast tego zdecydować się na podejście ręczne.

Tworząc Workflow (Tryb pracy) zamiast Reguły Globalnej, AI zadziała jako Twój bibliotekarz MemPalace wyłącznie wtedy, gdy wprost ją o to poprosisz. Daje Ci to 100% kontroli nad tym, kiedy wspomnienia są zapisywane lub przeszukiwane.

Oto jak skonfigurować ręczny tryb pracy:

1. Otwórz Antigravity IDE i przejdź do panelu Agent Chat.
2. Kliknij trzy kropki (...) w górnej części panelu czatu.
3. Wybierz Customisations i otwórz zakładkę Workflows.
4. Kliknij przycisk + Global.
5. Po wyświetleniu prośby o nazwę wpisz mempalace-integration-rules i naciśnij Enter.

Antigravity otworzy nowy plik.

Usuń z niego całą zawartość i zastąp ją w całości poniższym kodem:

---
description: Ręcznie wywołuje reguły pamięci MemPalace, automatyczną kategoryzację taksonomii oraz protokoły wyszukiwania międzyskrzydłowego.
---
# MemPalace Integration Rules

Jesteś połączony z systemem pamięci długoterminowej o nazwie MemPalace. Na czas trwania tego żądania działaj jako zautomatyzowany bibliotekarz.

## Taksonomia Skrzydeł (Wings) i Pokoi (Rooms)
- **Automatyczne wykrywanie Skrzydła:** Szukaj pliku `mempalace_wing.txt` w aktualnie aktywnym folderze. Jego zawartość reprezentuje nazwę Skrzydła.
- **Mechanizm awaryjny (Failsafe):** Jeśli plik `mempalace_wing.txt` nie zostanie znaleziony, NIE pozostawiaj pola Wing pustego. Użyj dokładnej nazwy bieżącego głównego folderu przestrzeni roboczej (lub aktywnego podfolderu).
- **Automatyczna kategoryzacja Pokoi:** NIE pytaj użytkownika o nazwę Pokoju. Na podstawie kontekstu naszej dzisiejszej rozmowy automatycznie zaklasyfikuj wspomnienie do jednego ze standardowych, zdefiniowanych wcześniej pokoi: `infrastructure`, `deployment`, `architecture`, `debugging`, `database` lub `general`.

## Protokoły operacyjne
1. **Najpierw przeszukaj:** Jeśli zadam Ci pytanie techniczne, użyj narzędzia wyszukiwania MemPalace, aby przed udzieleniem odpowiedzi sprawdzić istniejące wzorce w bieżącym Skrzydle i Pokoju.
2. **Tunele międzyskrzydłowe (Cross-Wing Tunnels):** Jeśli nie możesz znaleźć odpowiedzi lokalnie, wykonaj wyszukiwanie globalne, pozostawiając parametr `wing` PUSTY, aby wyciągnąć dane z moich innych projektów.
3. **Zapisuj rezultaty:** Zwięźle podsumuj decyzje techniczne, wzorce kodu i rozwiązania z naszej bieżącej rozmowy, a następnie zapisz je w odpowiednim Skrzydle i wywnioskowanym Pokoju.

Jak tego używać: Ponieważ jest to tryb pracy (workflow), działa on po cichu w tle, dopóki go nie potrzebujesz:

• Gdy zakończysz skomplikowaną sesję debugowania i zechcesz udokumentować rozwiązanie, po prostu otwórz czat i wpisz: /mempalace-integration-rules Zapisz proszę rozwiązanie, które właśnie ustaliliśmy.
• Z kolei jeśli chcesz, aby AI przeszukała Twoje poprzednie projekty przed udzieleniem odpowiedzi na nowe pytanie, zacznij prompt od: /mempalace-integration-rules Jak ostatnio konfigurowałem CSS?

Możesz wybrać wygodny dla siebie sposób integracji: albo regułę globalną w trybie „ustaw i zapomnij”, albo workflow w trybie „wywołaj, kiedy potrzebujesz”.

Testowanie Twojego automatycznego bibliotekarza

Zbudowaliśmy bazę danych, zabezpieczyliśmy tunel i zaprogramowaliśmy podświadomość AI. Pora udowodnić, że wszystko działa.

Test na żywo

1. Utwórz folder testowy, stwórz w nim plik o nazwie mempalace_wing.txt i wpisz w nim nazwę testową (np. test-project).

2. Otwórz fabrycznie nowy czat w Antigravity IDE.

3. Wpisz treść w stylu:

   „Zdecydowałem, że użyjemy PostgreSQL jako naszej bazy danych i będziemy się z nią łączyć za pomocą Prisma ORM. Przejdźmy dalej.”

Obserwuj, co się stanie. Nie prosiłeś o zapisanie czegokolwiek. Nie podałeś nazwy Skrzydła (Wing). Nie wskazałeś Pokoju (Room). Mimo to, dzięki Twoim Regułom Globalnym, AI powinna automatycznie wstrzymać pracę, wywołać narzędzie mempalace_add_drawer i zapisać podsumowanie.

Sprawdź wynik działania narzędzia.

Antigravity powinno wykonać to całkowicie samodzielnie, bez Twojej prośby:

1. Odczytanie otoczenia: Autonomicznie wywołało funkcje Listed directory oraz Viewed mempalace_wing.txt, aby ustalić, gdzie się znajduje. Pomyślnie odczytało wartość test-project.
2. Użycie narzędzi: Autonomicznie wywołało mempalace_add_drawer, aby zapisać Twoją decyzję architektoniczną. (Wygląda również na to, że Twój serwer MemPalace MCP ma narzędzie diary_write, a AI była tak gorliwa, że postanowiła zanotować w nim swoje przemyślenia!).
3. Tarcza zadziałała: Logi w moim Dockerze wskazują HTTP 192.168.1.1 - "POST /mcp HTTP/1.1" 200 -. Kod statusu 200 oznacza, że ruch pomyślnie przeszedł przez uwierzytelnianie Cloudflare Zero Trust, trafił do Twojego tunelu i zapisał dane bezpośrednio w Twojej lokalnej bazie danych.
4. Kontynuacja pracy: Po zapisaniu wspomnienia w skrzydle test-project w tle, AI powróciła do rozmowy i odpowiedziała na Twój prompt, przygotowując projekt planu wdrożenia Prisma.

Dowodzi to, że nasza automatyzacja bezwysiłkowa (Zero-Friction Automation) działa bez zarzutu. Właśnie zbudowaliśmy spersonalizowany, długoterminowy system pamięci działający pomiędzy projektami, który funkcjonuje całkowicie w tle.

Po udanym teście, aby wyczyścić naszą bazę danych MemPalace z projektów testowych, możemy wydać poniższe polecenie:

Znajdź wszystkie wspomnienia i wpisy w dzienniku w skrzydle test-project i usuń je.

Bonus: „Komenda zrzutu” / The Dump Command (Archiwizowanie poprzednich czatów)

A co z wszystkimi genialnymi rozwiązaniami problemów, które wypracowałeś przed zainstalowaniem MemPalace?

Prawdopodobnie masz wiele starych czatów pełnych wartościowych konfiguracji i decyzji. Nie chcesz ich stracić, ale ręczne kopiowanie i wklejanie zajęłoby godziny.

Możesz użyć Komendy zrzutu (Dump Command), aby AI wstecznie przeanalizowała stary czat i zapisała go w bazie.

Kwestia Skrzydła (Wing): Skąd AI ma wiedzieć, jakiego Skrzydła użyć dla starego czatu? Ponieważ nasze reguły globalne są zawsze aktywne, AI nadal będzie próbowała odczytać folder, który masz aktualnie otwarty. Stare czaty zawierają jednak ogromną ilość kontekstu. Aby zapobiec pomyłkom, najlepszą praktyką dla bezpieczeństwa jest wyraźne wskazanie nazwy Skrzydła w Komendzie Zrzutu.

Otwórz stary, wartościowy czat w swoim IDE i wysłij dokładnie taki prompt:

Komenda zrzutu: „Przeanalizuj całą tę historię czatu. Wyciągnij wszystkie ostateczne, działające decyzje architektoniczne, pliki konfiguracyjne i rozwiązane błędy. Zrób ich zwięzłe podsumowanie i zapisz je w MemPalace. Postępuj zgodnie z naszą standardową taksonomią Pokoi. Dla bezpieczeństwa wymuś nazwę Skrzydła (Wing): [Wstaw tutaj nazwę Skrzydła].”

AI przeskanuje całą historię tej rozmowy, podzieli ją na logiczne tematy i automatycznie posortuje do odpowiednich Pokoi (takich jak infrastructure czy debugging) wewnątrz wskazanego Skrzydła. Zadziała jak zautomatyzowany archiwista, zmieniając tygodnie chaotycznych logów z czatu w uporządkowaną, trwałą wiedzę!

Teraz przejdź do swoich projektów i utwórz pliki mempalace_wing.txt z nazwami skrzydeł, w szczególności w tych, nad którymi pracowałeś już w Antigravity.

Gratulacje – właśnie wyleczyłeś swoją sztuczną inteligencję z amnezji. Łącząc lokalnie hostowany MemPalace, nieprzeniknione tunele Cloudflare Zero Trust i reguły globalne w Antigravity, nie tylko skonfigurowałeś środowisko IDE. Zbudowałeś w pełni prywatny, dostępny z dowolnego miejsca na świecie drugi mózg, który uczy się za każdym razem, gdy kodujesz, nigdy nie zapomina poprawek błędów i podróżuje z Tobą, dokądkolwiek się udasz.

Krajobraz sztucznej inteligencji rozwija się w zawrotnym tempie, a popularne projekty będą pojawiać się i znikać. Jednak budując to rozwiązanie samodzielnie, nie tylko instalujesz narzędzie – opanowujesz protokół Model Context Protocol, zabezpieczasz lokalne kontenery Docker za pomocą Cloudflare Zero Trust i przejmujesz pełną kontrolę nad swoją infrastrukturą AI. Niezależnie od tego, jakie narzędzie do zarządzania pamięcią pojawi się w przyszłości, Twój homelab jest na nie gotowy.

Post Scriptum: Rzeczywistość pracy z modelami LLM

Po wdrożeniu powyższych kroków i korzystaniu z tej konfiguracji przez jakiś czas, możesz coś zauważyć: kiedy wysyłasz nowy prompt, wyraźnie widzisz (w logach twojego Dockers), jak AI komunikuje się z MemPalace, aby wyszukać kontekst przed udzieleniem odpowiedzi. Ale czasami, pod koniec długiej sesji kodowania lub po ostatecznym rozwiązaniu złożonego problemu, możesz nie zobaczyć, że automatycznie zapisuje wynik do pamięci.

Dlaczego tak się dzieje i czy automatyzacja w ogóle działa?

Po pierwsze, jest to w pełni zamierzone. W naszych Regułach Globalnych poinstruowaliśmy AI, aby zapisywała dane, gdy decyzja architektoniczna zostanie „sfinalizowana” lub błąd zostanie „rozwiązany”. Gdyby AI zapisywało każdy pojedynczy krok burzy mózgów lub każdą niedziałającą iterację Twojego kodu, Twoja wektorowa baza danych szybko zapełniłaby się bezużytecznym szumem. Celowo czeka więc na ostateczne wnioski.

Jednakże, koniec końców, LLM to wciąż tylko LLM.

Podczas długiego, skomplikowanego czatu agent może dostać swego rodzaju „klapek na oczach”. Staje się tak bardzo skupiony na rozwiązaniu problemu i dostarczeniu Ci ostatecznego, działającego kodu, że po prostu „zapomina” wywołać narzędzie mempalace_add_drawer w tej samej turze.

Jeśli zauważysz, że AI nie zarchiwizowało automatycznie genialnego rozwiązania, do którego właśnie doszliście, nie musisz pisać skomplikowanego polecenia ani ponownie ręcznie określać Skrzydła (Wing) i Pokoju (Room). Wystarczy, że dasz mu delikatną wskazówkę, aby zasygnalizować, że zadanie zostało zakończone.

Proste, naturalne zwroty konwersacyjne sprawdzą się idealnie:

• “Na razie to wszystko, wyślij nasze podejście/rozwiązanie do MemPalace.”
• “Świetnie, to działa idealnie. Udokumentuj to.”
• “Dobra robota, zapiszmy te ostateczne ustalenia w pamięci.”

To lekkie popchnięcie natychmiast przypomina agentowi o regule „Zapisuj rezultaty” (Save Outcomes Proactively). Ponieważ posiada on już pełny kontekst rozmowy i zna swoje Skrzydło dzięki regułom działającym w tle, płynnie wywoła narzędzie zapisu i odpowiednio skategoryzuje wiedzę.

Bezwysiłkowa automatyzacja jest niesamowita, ale czasami, jako główny programista (lead developer), musisz po prostu przypomnieć swojemu zautomatyzowanemu bibliotekarzowi, że spotkanie dobiegło końca i nadszedł czas na uporządkowanie notatek!